diff --git a/.gitattributes b/.gitattributes index c74f3b5e46d46f251a6d00499899614e3968a6b0..535770b05c2856f9858aab5d5864cc1a8cc83ed9 100644 --- a/.gitattributes +++ b/.gitattributes @@ -191,3 +191,60 @@ Demosaic/experiment/test/results-Urban100/img097_x1_DM.png filter=lfs diff=lfs m Demosaic/experiment/test/results-Urban100/img098_x1_DM.png filter=lfs diff=lfs merge=lfs -text Demosaic/experiment/test/results-Urban100/img099_x1_DM.png filter=lfs diff=lfs merge=lfs -text Demosaic/experiment/test/results-Urban100/img100_x1_DM.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img002_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img003_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img004_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img006_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img008_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img012_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img013_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img014_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img015_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img017_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img018_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img019_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img020_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img023_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img024_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img030_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img031_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img034_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img037_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img038_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img039_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img041_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img045_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img047_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img048_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img049_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img053_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img054_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img056_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img058_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img060_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img061_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img062_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img063_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img066_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img068_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img069_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img070_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img072_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img073_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img074_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img076_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img077_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img079_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img081_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img082_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img083_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img084_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img087_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img088_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img089_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img091_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img092_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img095_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img098_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img099_x50_DN.png filter=lfs diff=lfs merge=lfs -text +DN_RGB/experiment/test/results-Urban100/img100_x50_DN.png filter=lfs diff=lfs merge=lfs -text diff --git a/DN_RGB/.ipynb_checkpoints/Untitled-checkpoint.ipynb b/DN_RGB/.ipynb_checkpoints/Untitled-checkpoint.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..7fec51502cbc3200b3d0ffc6bbba1fe85e197f3d --- /dev/null +++ b/DN_RGB/.ipynb_checkpoints/Untitled-checkpoint.ipynb @@ -0,0 +1,6 @@ +{ + "cells": [], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/DN_RGB/.ipynb_checkpoints/Untitled1-checkpoint.ipynb b/DN_RGB/.ipynb_checkpoints/Untitled1-checkpoint.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..8d6e7ea6c80b5ed8b4613d8265ab6ac54dcbc8c3 --- /dev/null +++ b/DN_RGB/.ipynb_checkpoints/Untitled1-checkpoint.ipynb @@ -0,0 +1,59 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n" + ] + } + ], + "source": [ + "from time import sleep\n", + "for i in range(500):\n", + " print(i)\n", + " sleep(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/DN_RGB/README.md b/DN_RGB/README.md new file mode 100644 index 0000000000000000000000000000000000000000..9f37d21141e82ca1052b4c58435bac4dff99d383 --- /dev/null +++ b/DN_RGB/README.md @@ -0,0 +1,102 @@ +# Pyramid Attention for Image Restoration +This repository is for PANet and PA-EDSR introduced in the following paper + +[Yiqun Mei](http://yiqunm2.web.illinois.edu/), [Yuchen Fan](https://scholar.google.com/citations?user=BlfdYL0AAAAJ&hl=en), [Yulun Zhang](http://yulunzhang.com/), [Jiahui Yu](https://jiahuiyu.com/), [Yuqian Zhou](https://yzhouas.github.io/), [Ding Liu](https://scholar.google.com/citations?user=PGtHUI0AAAAJ&hl=en), [Yun Fu](http://www1.ece.neu.edu/~yunfu/), [Thomas S. Huang](http://ifp-uiuc.github.io/) and [Honghui Shi](https://www.humphreyshi.com/) "Pyramid Attention for Image Restoration", [[Arxiv]](https://arxiv.org/abs/2004.13824) + +The code is built on [EDSR (PyTorch)](https://github.com/thstkdgus35/EDSR-PyTorch) & [RNAN](https://github.com/yulunzhang/RNAN) and tested on Ubuntu 18.04 environment (Python3.6, PyTorch_1.1) with Titan X/1080Ti/V100 GPUs. + +## Contents +1. [Train](#train) +2. [Test](#test) +3. [Results](#results) +4. [Citation](#citation) +5. [Acknowledgements](#acknowledgements) + +## Train +### Prepare training data + +1. Download DIV2K training data (800 training + 100 validtion images) from [DIV2K dataset](https://data.vision.ee.ethz.ch/cvl/DIV2K/) or [SNU_CVLab](https://cv.snu.ac.kr/research/EDSR/DIV2K.tar). + +2. Specify '--dir_data' in optional.py based on the HR and LR images path. + +3. Organize training data like: +```bash +DIV2K/ +├── DIV2K_train_HR +├── DIV2K_train_LR_bicubic +│ └── X10 +│ └── X30 +│ └── X50 +│ └── X70 +├── DIV2K_valid_HR +└── DIV2K_valid_LR_bicubic + └── X10 + └── X30 + └── X50 + └── X70 +``` + +For more informaiton, please refer to [EDSR(PyTorch)](https://github.com/thstkdgus35/EDSR-PyTorch). + +### Begin to train + +1. (optional) All the pretrained models and visual results can be downloaded from [Google Drive](https://drive.google.com/open?id=1q9iUzqYX0fVRzDu4J6fvSPRosgOZoJJE). + +2. Cd to 'PANet-PyTorch/[Task]/code', run the following scripts to train models. + + **You can use scripts in file 'demo.sb' to train and test models for our paper.** + + ```bash + # Example Usage: N=10 + python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 80 --save_models --epoch 1000 --decay 200-400-600-800 --model PANET --scale 50 --patch_size 48 --reset --save PANET_N50 --n_feats 64 --data_train DIV2K --chop + ``` +## Test +### Quick start + +1. Cd to 'PANet-PyTorch/[Task]/code', run the following scripts. + + **You can use scripts in file 'demo.sb' to produce results for our paper.** + + ```bash + # No self-ensemble, use different testsets to reproduce the results in the paper. + # Example Usage: + python main.py --model PANET --n_resblocks 80 --n_feats 64 --data_test Urban100 --scale 10 --save_results --chop --test_only --pre_train ../path_to_model + ``` + +### The whole test pipeline +1. Prepare test data. Organize training data like: +```bash +benchmark/ +├── testset1 +│ └── HR +│ └── LR_bicubic +│ └── X10 +│ └── .. +├── testset2 +``` +2. Conduct image denoise. + + See **Quick start** +3. Evaluate the results. + + Run 'Evaluate_PSNR_SSIM.m' to obtain PSNR/SSIM values for paper. + +## Citation +If you find the code helpful in your resarch or work, please cite the following papers. +``` +@article{mei2020pyramid, + title={Pyramid Attention Networks for Image Restoration}, + author={Mei, Yiqun and Fan, Yuchen and Zhang, Yulun and Yu, Jiahui and Zhou, Yuqian and Liu, Ding and Fu, Yun and Huang, Thomas S and Shi, Honghui}, + journal={arXiv preprint arXiv:2004.13824}, + year={2020} +} +@InProceedings{Lim_2017_CVPR_Workshops, + author = {Lim, Bee and Son, Sanghyun and Kim, Heewon and Nah, Seungjun and Lee, Kyoung Mu}, + title = {Enhanced Deep Residual Networks for Single Image Super-Resolution}, + booktitle = {The IEEE Conference on Computer Vision and Pattern Recognition (CVPR) Workshops}, + month = {July}, + year = {2017} +} +``` +## Acknowledgements +This code is built on [EDSR (PyTorch)](https://github.com/thstkdgus35/EDSR-PyTorch), [RNAN](https://github.com/yulunzhang/RNAN) and [generative-inpainting-pytorch](https://github.com/daa233/generative-inpainting-pytorch). We thank the authors for sharing their codes. diff --git a/DN_RGB/Untitled.ipynb b/DN_RGB/Untitled.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..7fec51502cbc3200b3d0ffc6bbba1fe85e197f3d --- /dev/null +++ b/DN_RGB/Untitled.ipynb @@ -0,0 +1,6 @@ +{ + "cells": [], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/DN_RGB/Untitled1.ipynb b/DN_RGB/Untitled1.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..8d6e7ea6c80b5ed8b4613d8265ab6ac54dcbc8c3 --- /dev/null +++ b/DN_RGB/Untitled1.ipynb @@ -0,0 +1,59 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n" + ] + } + ], + "source": [ + "from time import sleep\n", + "for i in range(500):\n", + " print(i)\n", + " sleep(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/DN_RGB/code/.ipynb_checkpoints/train-1rec-raft-s-gpu1-checkpoint.sh b/DN_RGB/code/.ipynb_checkpoints/train-1rec-raft-s-gpu1-checkpoint.sh new file mode 100644 index 0000000000000000000000000000000000000000..49e14dddba0a6788ef803217c7e7b70c51aaad88 --- /dev/null +++ b/DN_RGB/code/.ipynb_checkpoints/train-1rec-raft-s-gpu1-checkpoint.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETSINGLE --scale 50 --patch_size 48 \ +--save RAFTSINGLE_N50_R1 --n_feats 64 --data_train DIV2K --recurrence 1 \ +--load RAFTSINGLE_N50_R1 --resume -1 \ No newline at end of file diff --git a/DN_RGB/code/.ipynb_checkpoints/train-1rec-raft-s-gpu1-nobn-checkpoint.sh b/DN_RGB/code/.ipynb_checkpoints/train-1rec-raft-s-gpu1-nobn-checkpoint.sh new file mode 100644 index 0000000000000000000000000000000000000000..9636241669ac2a236ff80e87e9cc0e765359e76c --- /dev/null +++ b/DN_RGB/code/.ipynb_checkpoints/train-1rec-raft-s-gpu1-nobn-checkpoint.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETSINGLE --scale 50 --patch_size 48 \ +--save RAFTSINGLE_N50_R1_nobn --n_feats 64 --data_train DIV2K --recurrence 1 --normalization none \ +--load RAFTSINGLE_N50_R1_nobn --resume -1 \ No newline at end of file diff --git a/DN_RGB/code/.ipynb_checkpoints/train-1rec-raft-s-gpu1-res-checkpoint.sh b/DN_RGB/code/.ipynb_checkpoints/train-1rec-raft-s-gpu1-res-checkpoint.sh new file mode 100644 index 0000000000000000000000000000000000000000..c4079583c3b4665089b4f24393e94f936f8705a3 --- /dev/null +++ b/DN_RGB/code/.ipynb_checkpoints/train-1rec-raft-s-gpu1-res-checkpoint.sh @@ -0,0 +1,24 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +# CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --decay 200-400-600-800 --epoch 1000 --batch_size 16 --n_resblocks 10 --save_models \ +# --model RAFTNETS --scale 1 --patch_size 48 --save RAFTS_DEMOSAIC20_R4 --n_feats 64 --data_train DIV2K --recurrence 4 --data_range "1-800/901-942" + +# python main.py --model LAMBDANET --n_resblocks 20 --recurrence 1 --save_results --n_GPUs 1 --chop --data_test McM+Kodak24+CBSD68+Urban100 --scale 1 \ +# --pre_train ../experiment/LAMBDA_DEMOSAIC20_R1/model/model_best.pt --test_only + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RESNET --scale 50 --patch_size 48 \ +--save RAFTS_RES --n_feats 64 --data_train DIV2K --recurrence 1 \ +--load RAFTS_RES --resume -1 \ No newline at end of file diff --git a/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-checkpoint.sh b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-checkpoint.sh new file mode 100644 index 0000000000000000000000000000000000000000..df6e9559aebcae88fdfaa07bbaacb8f2552a3278 --- /dev/null +++ b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-checkpoint.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_bn --n_feats 64 --data_train DIV2K --recurrence 4 \ +--load RAFTS_N50_R4_bn --resume -1 diff --git a/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-in-checkpoint.sh b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-in-checkpoint.sh new file mode 100644 index 0000000000000000000000000000000000000000..a3c49f53a754446e1bcf005d518463fcf4b644db --- /dev/null +++ b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-in-checkpoint.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_in --n_feats 64 --data_train DIV2K --recurrence 4 --normalization instance \ +--resume -1 --load RAFTS_N50_R4_in \ No newline at end of file diff --git a/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-large-checkpoint.sh b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-large-checkpoint.sh new file mode 100644 index 0000000000000000000000000000000000000000..8b982059f751acdba5de4934728f0318421b2d62 --- /dev/null +++ b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-large-checkpoint.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 96 \ +--save RAFTS_N50_R4_bn_large --n_feats 64 --data_train DIV2K --recurrence 4 \ +--load RAFTS_N50_R4_bn_large --resume -1 diff --git a/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-ln-checkpoint.sh b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-ln-checkpoint.sh new file mode 100644 index 0000000000000000000000000000000000000000..518ea3e31aaff05012c6471ea8deada43c9c6f00 --- /dev/null +++ b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-ln-checkpoint.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 --reset \ +--save RAFTS_N50_R4_ln --n_feats 64 --data_train DIV2K --recurrence 4 --normalization layer \ No newline at end of file diff --git a/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-ln-gclip-checkpoint.sh b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-ln-gclip-checkpoint.sh new file mode 100644 index 0000000000000000000000000000000000000000..1bbf4e7d1738f3dc8f9217f80d657384de7647bd --- /dev/null +++ b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-ln-gclip-checkpoint.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_ln_clip --n_feats 64 --data_train DIV2K --recurrence 4 --normalization layer --gclip 1.2 \ +--load RAFTS_N50_R4_ln_clip --resume -1 \ No newline at end of file diff --git a/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-ln-large-checkpoint.sh b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-ln-large-checkpoint.sh new file mode 100644 index 0000000000000000000000000000000000000000..389523c097b7a3d085b0c3a9646973c1b2093e82 --- /dev/null +++ b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-ln-large-checkpoint.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 96 --reset \ +--save RAFTS_N50_R4_ln_large --n_feats 64 --data_train DIV2K --recurrence 4 --normalization layer \ No newline at end of file diff --git a/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-ln-small-checkpoint.sh b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-ln-small-checkpoint.sh new file mode 100644 index 0000000000000000000000000000000000000000..bb0b15de0a6397a37e8d6537903e12373e6eab65 --- /dev/null +++ b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-ln-small-checkpoint.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 64 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 24 --reset \ +--save RAFTS_N50_R4_ln_small --n_feats 64 --data_train DIV2K --recurrence 4 --normalization layer --gclip 1.2 \ No newline at end of file diff --git a/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-nobn-checkpoint.sh b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-nobn-checkpoint.sh new file mode 100644 index 0000000000000000000000000000000000000000..52fefdbfb22dcd62aa5bcf9c658380eb9f64af65 --- /dev/null +++ b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-nobn-checkpoint.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_nobn --n_feats 64 --data_train DIV2K --recurrence 4 --normalization none \ +--load RAFTS_N50_R4_nobn --resume -1 diff --git a/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-nobn-nores-checkpoint.sh b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-nobn-nores-checkpoint.sh new file mode 100644 index 0000000000000000000000000000000000000000..8d7fa627219070929531644f76ce936a79346838 --- /dev/null +++ b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-nobn-nores-checkpoint.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETSNORES --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_nobn_nores --n_feats 64 --data_train DIV2K --recurrence 4 --normalization none --detach \ +--load RAFTS_N50_R4_nobn_nores --resume -1 diff --git a/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-nobn-res10-checkpoint.sh b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-nobn-res10-checkpoint.sh new file mode 100644 index 0000000000000000000000000000000000000000..4249b09b8daf90fcb053c24959981c629e7bf725 --- /dev/null +++ b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-nobn-res10-checkpoint.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 10 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_nobn_res10 --n_feats 64 --data_train DIV2K --recurrence 4 --normalization none \ +--load RAFTS_N50_R4_nobn_res10 --resume -1 \ No newline at end of file diff --git a/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-small-checkpoint.sh b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-small-checkpoint.sh new file mode 100644 index 0000000000000000000000000000000000000000..87e3da9f10f308b418e0722ba997a100d64d51ff --- /dev/null +++ b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu1-small-checkpoint.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 24 --reset \ +--save RAFTS_N50_R4_bn_small --n_feats 64 --data_train DIV2K --recurrence 4 \ No newline at end of file diff --git a/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu2-nobn-checkpoint.sh b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu2-nobn-checkpoint.sh new file mode 100644 index 0000000000000000000000000000000000000000..d08ef00085f16dd5ae06ff6955a95f7619720050 --- /dev/null +++ b/DN_RGB/code/.ipynb_checkpoints/train-4rec-raft-s-gpu2-nobn-checkpoint.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=0,3 python main.py --n_GPUs 2 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_nobn --n_feats 64 --data_train DIV2K --recurrence 4 --normalization none \ +--load RAFTS_N50_R4_nobn --resume -1 diff --git a/DN_RGB/code/.ipynb_checkpoints/train-checkpoint.sh b/DN_RGB/code/.ipynb_checkpoints/train-checkpoint.sh new file mode 100644 index 0000000000000000000000000000000000000000..e09d33088512568d843804f6bd7eb17619dcb4a3 --- /dev/null +++ b/DN_RGB/code/.ipynb_checkpoints/train-checkpoint.sh @@ -0,0 +1,4 @@ +#!/bin/bash +bash ./prepare.sh +CUDA_VISIBLE_DEVICES=0 python main.py --n_GPUs 1 --lr 1e-5 --batch_size 16 --save_models --epoch 100 --model PANET \ +--scale 50 --patch_size 48 --reset --save MDSR_att_N50 --n_feats 64 --data_train DIV2K --chop --dir_data="/data/ssd/public/liuhy/sr/dataset" diff --git a/DN_RGB/code/.ipynb_checkpoints/trainer-checkpoint.py b/DN_RGB/code/.ipynb_checkpoints/trainer-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..8c581f96260cdbc39324e32593fb216577f48a22 --- /dev/null +++ b/DN_RGB/code/.ipynb_checkpoints/trainer-checkpoint.py @@ -0,0 +1,182 @@ +import os +import math +from decimal import Decimal + +import utility + +import torch +import torch.nn.utils as utils +from tqdm import tqdm + +import torch.cuda.amp as amp + +from torch.utils.tensorboard import SummaryWriter +import torchvision + +import numpy as np + +class Trainer(): + def __init__(self, args, loader, my_model, my_loss, ckp): + self.args = args + self.scale = args.scale + + self.ckp = ckp + self.loader_train = loader.loader_train + self.loader_test = loader.loader_test + self.model = my_model + self.loss = my_loss + self.optimizer = utility.make_optimizer(args, self.model) + + if self.args.load != '': + self.optimizer.load(ckp.dir, epoch=len(ckp.log)) + + self.error_last = 1e8 + self.scaler=amp.GradScaler( + enabled=args.amp + ) + self.writter=None + self.recurrence=args.recurrence + if args.recurrence>1: + self.writter=SummaryWriter(f"runs/{args.save}") + + def train(self): + self.loss.step() + epoch = self.optimizer.get_last_epoch() + 1 + lr = self.optimizer.get_lr() + + self.ckp.write_log( + '[Epoch {}]\tLearning rate: {:.2e}'.format(epoch, Decimal(lr)) + ) + self.loss.start_log() + self.model.train() + + timer_data, timer_model = utility.timer(), utility.timer() + # TEMP + self.loader_train.dataset.set_scale(0) + total=len(self.loader_train) + buffer=[0.0]*self.recurrence + # torch.autograd.set_detect_anomaly(True) + for batch, (lr, hr, _,) in enumerate(self.loader_train): + lr, hr = self.prepare(lr, hr) + # print(lr.min(),lr.max(), hr.min(),hr.max()) + # exit(0) + timer_data.hold() + timer_model.tic() + + self.optimizer.zero_grad() + with amp.autocast(self.args.amp): + sr = self.model(lr, 0) + if len(sr)==1: + sr=sr[0] + # loss,buffer_lst=sequence_loss(sr,hr) + loss = self.loss(sr, hr) + self.scaler.scale(loss).backward() + if self.args.gclip > 0: + self.scaler.unscale_(self.optimizer) + utils.clip_grad_value_( + self.model.parameters(), + self.args.gclip + ) + self.scaler.step(self.optimizer) + self.scaler.update() + for i in range(self.recurrence): + buffer[i]+=self.loss.buffer[i] + # self.optimizer.step() + + timer_model.hold() + + if (batch + 1) % self.args.print_every == 0: + self.ckp.write_log('[{}/{}]\t{}\t{:.1f}+{:.1f}s'.format( + (batch + 1) * self.args.batch_size, + len(self.loader_train.dataset), + self.loss.display_loss(batch), + timer_model.release(), + timer_data.release())) + + timer_data.tic() + if self.writter: + for i in range(self.recurrence): + grid=torchvision.utils.make_grid(sr[i]) + self.writter.add_image(f"Output{i}",grid,epoch) + self.writter.add_scalar(f"Loss{i}",buffer[i]/total,epoch) + self.writter.add_image("Input",torchvision.utils.make_grid(lr),epoch) + self.writter.add_image("Target",torchvision.utils.make_grid(hr),epoch) + self.loss.end_log(len(self.loader_train)) + self.error_last = self.loss.log[-1, -1] + self.optimizer.schedule() + + def test(self): + torch.set_grad_enabled(False) + + epoch = self.optimizer.get_last_epoch() + self.ckp.write_log('\nEvaluation:') + self.ckp.add_log( + torch.zeros(1, len(self.loader_test), len(self.scale)) + ) + self.model.eval() + + timer_test = utility.timer() + if self.args.save_results: self.ckp.begin_background() + for idx_data, d in enumerate(self.loader_test): + for idx_scale, scale in enumerate(self.scale): + d.dataset.set_scale(idx_scale) + for lr, hr, filename in tqdm(d, ncols=80): + lr, hr = self.prepare(lr, hr) + with amp.autocast(self.args.amp): + sr = self.model(lr, idx_scale) + if isinstance(sr,list): + sr=sr[-1] + sr = utility.quantize(sr, self.args.rgb_range) + + save_list = [sr] + self.ckp.log[-1, idx_data, idx_scale] += utility.calc_psnr( + sr, hr, scale, self.args.rgb_range, dataset=d + ) + if self.args.save_gt: + save_list.extend([lr, hr]) + + if self.args.save_results: + self.ckp.save_results(d, filename[0], save_list, scale) + + self.ckp.log[-1, idx_data, idx_scale] /= len(d) + best = self.ckp.log.max(0) + self.ckp.write_log( + '[{} x{}]\tPSNR: {:.3f} (Best: {:.3f} @epoch {})'.format( + d.dataset.name, + scale, + self.ckp.log[-1, idx_data, idx_scale], + best[0][idx_data, idx_scale], + best[1][idx_data, idx_scale] + 1 + ) + ) + self.ckp.write_log('Forward: {:.2f}s\n'.format(timer_test.toc())) + self.ckp.write_log('Saving...') + # torch.cuda.empty_cache() + if self.args.save_results: + self.ckp.end_background() + + if not self.args.test_only: + self.ckp.save(self, epoch, is_best=(best[1][0, 0] + 1 == epoch)) + + self.ckp.write_log( + 'Total: {:.2f}s\n'.format(timer_test.toc()), refresh=True + ) + + torch.set_grad_enabled(True) + + def prepare(self, *args): + device = torch.device('cpu' if self.args.cpu else 'cuda') + def _prepare(tensor): + if self.args.precision == 'half': tensor = tensor.half() + return tensor.to(device) + + return [_prepare(a) for a in args] + + def terminate(self): + if self.args.test_only: + self.test() + return True + else: + epoch = self.optimizer.get_last_epoch() + 1 + return epoch >= self.args.epochs + diff --git a/DN_RGB/code/LICENSE b/DN_RGB/code/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..df2326a5dce9106825799c73dfab581cbde1f96c --- /dev/null +++ b/DN_RGB/code/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 Sanghyun Son + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/DN_RGB/code/__init__.py b/DN_RGB/code/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/DN_RGB/code/__pycache__/__init__.cpython-37.pyc b/DN_RGB/code/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..063925f210f02f7563666e9ec4c654f4eb168d61 Binary files /dev/null and b/DN_RGB/code/__pycache__/__init__.cpython-37.pyc differ diff --git a/DN_RGB/code/__pycache__/option.cpython-36.pyc b/DN_RGB/code/__pycache__/option.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c6a3ba97f7524dec716acd08fba2b0f098c429cc Binary files /dev/null and b/DN_RGB/code/__pycache__/option.cpython-36.pyc differ diff --git a/DN_RGB/code/__pycache__/option.cpython-37.pyc b/DN_RGB/code/__pycache__/option.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..911e3d58dfff20810246db90ba2a4e5ad0d1cb9f Binary files /dev/null and b/DN_RGB/code/__pycache__/option.cpython-37.pyc differ diff --git a/DN_RGB/code/__pycache__/template.cpython-36.pyc b/DN_RGB/code/__pycache__/template.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4e53db9e5d2e696df95b8ee54e1068030349185c Binary files /dev/null and b/DN_RGB/code/__pycache__/template.cpython-36.pyc differ diff --git a/DN_RGB/code/__pycache__/template.cpython-37.pyc b/DN_RGB/code/__pycache__/template.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1452e396b6190f5bdd8059969087314a63579354 Binary files /dev/null and b/DN_RGB/code/__pycache__/template.cpython-37.pyc differ diff --git a/DN_RGB/code/__pycache__/trainer.cpython-36.pyc b/DN_RGB/code/__pycache__/trainer.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5a1a73cc99b25bd0e53b607c42d12d8a7fd30d40 Binary files /dev/null and b/DN_RGB/code/__pycache__/trainer.cpython-36.pyc differ diff --git a/DN_RGB/code/__pycache__/trainer.cpython-37.pyc b/DN_RGB/code/__pycache__/trainer.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8658b4a0e8a490cb46d6d8e09776deed93abc46b Binary files /dev/null and b/DN_RGB/code/__pycache__/trainer.cpython-37.pyc differ diff --git a/DN_RGB/code/__pycache__/utility.cpython-36.pyc b/DN_RGB/code/__pycache__/utility.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c9c9e009ca3687a1a28008f60c50f663937b2862 Binary files /dev/null and b/DN_RGB/code/__pycache__/utility.cpython-36.pyc differ diff --git a/DN_RGB/code/__pycache__/utility.cpython-37.pyc b/DN_RGB/code/__pycache__/utility.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c4865442be773aa9c38a290fec266c0c8f4f32fa Binary files /dev/null and b/DN_RGB/code/__pycache__/utility.cpython-37.pyc differ diff --git a/DN_RGB/code/data/__init__.py b/DN_RGB/code/data/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b492de40fd3898458608ec35ad8b9c27a67813bf --- /dev/null +++ b/DN_RGB/code/data/__init__.py @@ -0,0 +1,52 @@ +from importlib import import_module +#from dataloader import MSDataLoader +from torch.utils.data import dataloader +from torch.utils.data import ConcatDataset + +# This is a simple wrapper function for ConcatDataset +class MyConcatDataset(ConcatDataset): + def __init__(self, datasets): + super(MyConcatDataset, self).__init__(datasets) + self.train = datasets[0].train + + def set_scale(self, idx_scale): + for d in self.datasets: + if hasattr(d, 'set_scale'): d.set_scale(idx_scale) + +class Data: + def __init__(self, args): + self.loader_train = None + if not args.test_only: + datasets = [] + for d in args.data_train: + module_name = d if d.find('DIV2K-Q') < 0 else 'DIV2KJPEG' + m = import_module('data.' + module_name.lower()) + datasets.append(getattr(m, module_name)(args, name=d)) + + self.loader_train = dataloader.DataLoader( + MyConcatDataset(datasets), + batch_size=args.batch_size, + shuffle=True, + pin_memory=not args.cpu, + num_workers=args.n_threads, + ) + + self.loader_test = [] + for d in args.data_test: + if d in ['CBSD68','Kodak24','Set5', 'Set14', 'B100', 'Urban100']: + m = import_module('data.benchmark') + testset = getattr(m, 'Benchmark')(args, train=False, name=d) + else: + module_name = d if d.find('DIV2K-Q') < 0 else 'DIV2KJPEG' + m = import_module('data.' + module_name.lower()) + testset = getattr(m, module_name)(args, train=False, name=d) + + self.loader_test.append( + dataloader.DataLoader( + testset, + batch_size=1, + shuffle=False, + pin_memory=not args.cpu, + num_workers=args.n_threads, + ) + ) diff --git a/DN_RGB/code/data/__pycache__/__init__.cpython-36.pyc b/DN_RGB/code/data/__pycache__/__init__.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..98605bd1db15c662125e334b16fb067b842984fa Binary files /dev/null and b/DN_RGB/code/data/__pycache__/__init__.cpython-36.pyc differ diff --git a/DN_RGB/code/data/__pycache__/__init__.cpython-37.pyc b/DN_RGB/code/data/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..06d2c1f4e91904038b1727c6fd24eece6611be4c Binary files /dev/null and b/DN_RGB/code/data/__pycache__/__init__.cpython-37.pyc differ diff --git a/DN_RGB/code/data/__pycache__/benchmark.cpython-36.pyc b/DN_RGB/code/data/__pycache__/benchmark.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2fd011cd2326700539bbb85c68853ecae4c92242 Binary files /dev/null and b/DN_RGB/code/data/__pycache__/benchmark.cpython-36.pyc differ diff --git a/DN_RGB/code/data/__pycache__/benchmark.cpython-37.pyc b/DN_RGB/code/data/__pycache__/benchmark.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ffb9bebd9a3ee8469d2c1f387f516fc857f0ef0d Binary files /dev/null and b/DN_RGB/code/data/__pycache__/benchmark.cpython-37.pyc differ diff --git a/DN_RGB/code/data/__pycache__/common.cpython-36.pyc b/DN_RGB/code/data/__pycache__/common.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3f5712b114b2432768a8e7a36fb2445cfeded975 Binary files /dev/null and b/DN_RGB/code/data/__pycache__/common.cpython-36.pyc differ diff --git a/DN_RGB/code/data/__pycache__/common.cpython-37.pyc b/DN_RGB/code/data/__pycache__/common.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b7f96542e2725cb2fa7093c89921552a91e9d80a Binary files /dev/null and b/DN_RGB/code/data/__pycache__/common.cpython-37.pyc differ diff --git a/DN_RGB/code/data/__pycache__/div2k.cpython-36.pyc b/DN_RGB/code/data/__pycache__/div2k.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..92d29645cff186944648f79c92be794305ac8d6a Binary files /dev/null and b/DN_RGB/code/data/__pycache__/div2k.cpython-36.pyc differ diff --git a/DN_RGB/code/data/__pycache__/div2k.cpython-37.pyc b/DN_RGB/code/data/__pycache__/div2k.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..341f6cafa833a3dc0aa3ce22a9dfabf30006392f Binary files /dev/null and b/DN_RGB/code/data/__pycache__/div2k.cpython-37.pyc differ diff --git a/DN_RGB/code/data/__pycache__/srdata.cpython-36.pyc b/DN_RGB/code/data/__pycache__/srdata.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..882c4e8e60debe51eae57b5e4f64235e1be80211 Binary files /dev/null and b/DN_RGB/code/data/__pycache__/srdata.cpython-36.pyc differ diff --git a/DN_RGB/code/data/__pycache__/srdata.cpython-37.pyc b/DN_RGB/code/data/__pycache__/srdata.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6e2d8e127032fb1388fc97bec003a72acb7734cf Binary files /dev/null and b/DN_RGB/code/data/__pycache__/srdata.cpython-37.pyc differ diff --git a/DN_RGB/code/data/benchmark.py b/DN_RGB/code/data/benchmark.py new file mode 100644 index 0000000000000000000000000000000000000000..da851038dd982aefc74918b850683878962881ae --- /dev/null +++ b/DN_RGB/code/data/benchmark.py @@ -0,0 +1,25 @@ +import os + +from data import common +from data import srdata + +import numpy as np + +import torch +import torch.utils.data as data + +class Benchmark(srdata.SRData): + def __init__(self, args, name='', train=True, benchmark=True): + super(Benchmark, self).__init__( + args, name=name, train=train, benchmark=True + ) + + def _set_filesystem(self, dir_data): + self.apath = os.path.join(dir_data, 'benchmark', self.name) + self.dir_hr = os.path.join(self.apath, 'HR') + if self.input_large: + self.dir_lr = os.path.join(self.apath, 'LR_bicubicL') + else: + self.dir_lr = os.path.join(self.apath, 'LR_bicubic') + self.ext = ('', '.png') + diff --git a/DN_RGB/code/data/common.py b/DN_RGB/code/data/common.py new file mode 100644 index 0000000000000000000000000000000000000000..0d9abfa15baf5fd2a23a7b305fb83c427ebc4d26 --- /dev/null +++ b/DN_RGB/code/data/common.py @@ -0,0 +1,72 @@ +import random + +import numpy as np +import skimage.color as sc + +import torch + +def get_patch(*args, patch_size=96, scale=1, multi=False, input_large=False): + ih, iw = args[0].shape[:2] + + if not input_large: + p = 1 if multi else 1 + tp = p * patch_size + ip = tp // 1 + else: + tp = patch_size + ip = patch_size + + ix = random.randrange(0, iw - ip + 1) + iy = random.randrange(0, ih - ip + 1) + + if not input_large: + tx, ty = 1 * ix, 1 * iy + else: + tx, ty = ix, iy + + ret = [ + args[0][iy:iy + ip, ix:ix + ip, :], + *[a[ty:ty + tp, tx:tx + tp, :] for a in args[1:]] + ] + + return ret + +def set_channel(*args, n_channels=3): + def _set_channel(img): + if img.ndim == 2: + img = np.expand_dims(img, axis=2) + + c = img.shape[2] + if n_channels == 1 and c == 3: + img = np.expand_dims(sc.rgb2ycbcr(img)[:, :, 0], 2) + elif n_channels == 3 and c == 1: + img = np.concatenate([img] * n_channels, 2) + + return img + + return [_set_channel(a) for a in args] + +def np2Tensor(*args, rgb_range=255): + def _np2Tensor(img): + np_transpose = np.ascontiguousarray(img.transpose((2, 0, 1))) + tensor = torch.from_numpy(np_transpose).float() + tensor.mul_(rgb_range / 255) + + return tensor + + return [_np2Tensor(a) for a in args] + +def augment(*args, hflip=True, rot=True): + hflip = hflip and random.random() < 0.5 + vflip = rot and random.random() < 0.5 + rot90 = rot and random.random() < 0.5 + + def _augment(img): + if hflip: img = img[:, ::-1, :] + if vflip: img = img[::-1, :, :] + if rot90: img = img.transpose(1, 0, 2) + + return img + + return [_augment(a) for a in args] + diff --git a/DN_RGB/code/data/demo.py b/DN_RGB/code/data/demo.py new file mode 100644 index 0000000000000000000000000000000000000000..316b9e0d666f46ec52cfc78f3b9f5c3e26c7e97c --- /dev/null +++ b/DN_RGB/code/data/demo.py @@ -0,0 +1,39 @@ +import os + +from data import common + +import numpy as np +import imageio + +import torch +import torch.utils.data as data + +class Demo(data.Dataset): + def __init__(self, args, name='Demo', train=False, benchmark=False): + self.args = args + self.name = name + self.scale = args.scale + self.idx_scale = 0 + self.train = False + self.benchmark = benchmark + + self.filelist = [] + for f in os.listdir(args.dir_demo): + if f.find('.png') >= 0 or f.find('.jp') >= 0: + self.filelist.append(os.path.join(args.dir_demo, f)) + self.filelist.sort() + + def __getitem__(self, idx): + filename = os.path.splitext(os.path.basename(self.filelist[idx]))[0] + lr = imageio.imread(self.filelist[idx]) + lr, = common.set_channel(lr, n_channels=self.args.n_colors) + lr_t, = common.np2Tensor(lr, rgb_range=self.args.rgb_range) + + return lr_t, -1, filename + + def __len__(self): + return len(self.filelist) + + def set_scale(self, idx_scale): + self.idx_scale = idx_scale + diff --git a/DN_RGB/code/data/div2k.py b/DN_RGB/code/data/div2k.py new file mode 100644 index 0000000000000000000000000000000000000000..f1c9bcd9788731e29a76db864cccd1e42ba9de88 --- /dev/null +++ b/DN_RGB/code/data/div2k.py @@ -0,0 +1,32 @@ +import os +from data import srdata + +class DIV2K(srdata.SRData): + def __init__(self, args, name='DIV2K', train=True, benchmark=False): + data_range = [r.split('-') for r in args.data_range.split('/')] + if train: + data_range = data_range[0] + else: + if args.test_only and len(data_range) == 1: + data_range = data_range[0] + else: + data_range = data_range[1] + + self.begin, self.end = list(map(lambda x: int(x), data_range)) + super(DIV2K, self).__init__( + args, name=name, train=train, benchmark=benchmark + ) + + def _scan(self): + names_hr, names_lr = super(DIV2K, self)._scan() + names_hr = names_hr[self.begin - 1:self.end] + names_lr = [n[self.begin - 1:self.end] for n in names_lr] + + return names_hr, names_lr + + def _set_filesystem(self, dir_data): + super(DIV2K, self)._set_filesystem(dir_data) + self.dir_hr = os.path.join(self.apath, 'DIV2K_train_HR') + self.dir_lr = os.path.join(self.apath, 'DIV2K_train_LR_bicubic') + if self.input_large: self.dir_lr += 'L' + diff --git a/DN_RGB/code/data/div2kjpeg.py b/DN_RGB/code/data/div2kjpeg.py new file mode 100644 index 0000000000000000000000000000000000000000..0bfc6b03b3946ba664861cddf13f95f46c12cee8 --- /dev/null +++ b/DN_RGB/code/data/div2kjpeg.py @@ -0,0 +1,20 @@ +import os +from data import srdata +from data import div2k + +class DIV2KJPEG(div2k.DIV2K): + def __init__(self, args, name='', train=True, benchmark=False): + self.q_factor = int(name.replace('DIV2K-Q', '')) + super(DIV2KJPEG, self).__init__( + args, name=name, train=train, benchmark=benchmark + ) + + def _set_filesystem(self, dir_data): + self.apath = os.path.join(dir_data, 'DIV2K') + self.dir_hr = os.path.join(self.apath, 'DIV2K_train_HR') + self.dir_lr = os.path.join( + self.apath, 'DIV2K_Q{}'.format(self.q_factor) + ) + if self.input_large: self.dir_lr += 'L' + self.ext = ('.png', '.jpg') + diff --git a/DN_RGB/code/data/sr291.py b/DN_RGB/code/data/sr291.py new file mode 100644 index 0000000000000000000000000000000000000000..f60ad951ef7ec61d98456f8a2ccec5296befe4cd --- /dev/null +++ b/DN_RGB/code/data/sr291.py @@ -0,0 +1,6 @@ +from data import srdata + +class SR291(srdata.SRData): + def __init__(self, args, name='SR291', train=True, benchmark=False): + super(SR291, self).__init__(args, name=name) + diff --git a/DN_RGB/code/data/srdata.py b/DN_RGB/code/data/srdata.py new file mode 100644 index 0000000000000000000000000000000000000000..d036b10b7cffe54079ee80bfc171716bd1934d7a --- /dev/null +++ b/DN_RGB/code/data/srdata.py @@ -0,0 +1,157 @@ +import os +import glob +import random +import pickle + +from data import common + +import numpy as np +import imageio +import torch +import torch.utils.data as data + +class SRData(data.Dataset): + def __init__(self, args, name='', train=True, benchmark=False): + self.args = args + self.name = name + self.train = train + self.split = 'train' if train else 'test' + self.do_eval = True + self.benchmark = benchmark + self.input_large = (args.model == 'VDSR') + self.scale = args.scale + self.idx_scale = 0 + + self._set_filesystem(args.dir_data) + if args.ext.find('img') < 0: + path_bin = os.path.join(self.apath, 'bin') + os.makedirs(path_bin, exist_ok=True) + + list_hr, list_lr = self._scan() + if args.ext.find('img') >= 0 or benchmark: + self.images_hr, self.images_lr = list_hr, list_lr + elif args.ext.find('sep') >= 0: + os.makedirs( + self.dir_hr.replace(self.apath, path_bin), + exist_ok=True + ) + for s in self.scale: + os.makedirs( + os.path.join( + self.dir_lr.replace(self.apath, path_bin), + 'X{}'.format(s) + ), + exist_ok=True + ) + + self.images_hr, self.images_lr = [], [[] for _ in self.scale] + for h in list_hr: + b = h.replace(self.apath, path_bin) + b = b.replace(self.ext[0], '.pt') + self.images_hr.append(b) + self._check_and_load(args.ext, h, b, verbose=True) + for i, ll in enumerate(list_lr): + for l in ll: + b = l.replace(self.apath, path_bin) + b = b.replace(self.ext[1], '.pt') + self.images_lr[i].append(b) + self._check_and_load(args.ext, l, b, verbose=True) + if train: + n_patches = args.batch_size * args.test_every + n_images = len(args.data_train) * len(self.images_hr) + if n_images == 0: + self.repeat = 0 + else: + self.repeat = max(n_patches // n_images, 1) + + # Below functions as used to prepare images + def _scan(self): + names_hr = sorted( + glob.glob(os.path.join(self.dir_hr, '*' + self.ext[0])) + ) + names_lr = [[] for _ in self.scale] + for f in names_hr: + filename, _ = os.path.splitext(os.path.basename(f)) + for si, s in enumerate(self.scale): + names_lr[si].append(os.path.join( + self.dir_lr, 'X{}/{}x{}{}'.format( + s, filename, s, self.ext[1] + ) + )) + + return names_hr, names_lr + + def _set_filesystem(self, dir_data): + self.apath = os.path.join(dir_data, self.name) + self.dir_hr = os.path.join(self.apath, 'HR') + self.dir_lr = os.path.join(self.apath, 'LR_bicubic') + if self.input_large: self.dir_lr += 'L' + self.ext = ('.png', '.png') + + def _check_and_load(self, ext, img, f, verbose=True): + if not os.path.isfile(f) or ext.find('reset') >= 0: + if verbose: + print('Making a binary: {}'.format(f)) + with open(f, 'wb') as _f: + pickle.dump(imageio.imread(img), _f) + + def __getitem__(self, idx): + lr, hr, filename = self._load_file(idx) + pair = self.get_patch(lr, hr) + pair = common.set_channel(*pair, n_channels=self.args.n_colors) + pair_t = common.np2Tensor(*pair, rgb_range=self.args.rgb_range) + + return pair_t[0], pair_t[1], filename + + def __len__(self): + if self.train: + return len(self.images_hr) * self.repeat + else: + return len(self.images_hr) + + def _get_index(self, idx): + if self.train: + return idx % len(self.images_hr) + else: + return idx + + def _load_file(self, idx): + idx = self._get_index(idx) + f_hr = self.images_hr[idx] + f_lr = self.images_lr[self.idx_scale][idx] + + filename, _ = os.path.splitext(os.path.basename(f_hr)) + if self.args.ext == 'img' or self.benchmark: + hr = imageio.imread(f_hr) + lr = imageio.imread(f_lr) + elif self.args.ext.find('sep') >= 0: + with open(f_hr, 'rb') as _f: + hr = pickle.load(_f) + with open(f_lr, 'rb') as _f: + lr = pickle.load(_f) + + return lr, hr, filename + + def get_patch(self, lr, hr): + scale = self.scale[self.idx_scale] + if self.train: + lr, hr = common.get_patch( + lr, hr, + patch_size=self.args.patch_size, + scale=scale, + multi=(len(self.scale) > 1), + input_large=self.input_large + ) + if not self.args.no_augment: lr, hr = common.augment(lr, hr) + else: + ih, iw = lr.shape[:2] + hr = hr[0:ih * scale, 0:iw * scale] + + return lr, hr + + def set_scale(self, idx_scale): + if not self.input_large: + self.idx_scale = idx_scale + else: + self.idx_scale = random.randint(0, len(self.scale) - 1) + diff --git a/DN_RGB/code/data/video.py b/DN_RGB/code/data/video.py new file mode 100644 index 0000000000000000000000000000000000000000..76181b6ffa119172df0f46615e6a1e8b867e104c --- /dev/null +++ b/DN_RGB/code/data/video.py @@ -0,0 +1,44 @@ +import os + +from data import common + +import cv2 +import numpy as np +import imageio + +import torch +import torch.utils.data as data + +class Video(data.Dataset): + def __init__(self, args, name='Video', train=False, benchmark=False): + self.args = args + self.name = name + self.scale = args.scale + self.idx_scale = 0 + self.train = False + self.do_eval = False + self.benchmark = benchmark + + self.filename, _ = os.path.splitext(os.path.basename(args.dir_demo)) + self.vidcap = cv2.VideoCapture(args.dir_demo) + self.n_frames = 0 + self.total_frames = int(self.vidcap.get(cv2.CAP_PROP_FRAME_COUNT)) + + def __getitem__(self, idx): + success, lr = self.vidcap.read() + if success: + self.n_frames += 1 + lr, = common.set_channel(lr, n_channels=self.args.n_colors) + lr_t, = common.np2Tensor(lr, rgb_range=self.args.rgb_range) + + return lr_t, -1, '{}_{:0>5}'.format(self.filename, self.n_frames) + else: + vidcap.release() + return None + + def __len__(self): + return self.total_frames + + def set_scale(self, idx_scale): + self.idx_scale = idx_scale + diff --git a/DN_RGB/code/dataloader.py b/DN_RGB/code/dataloader.py new file mode 100644 index 0000000000000000000000000000000000000000..350af9a02281c1300cf9f48ec4f57a7bb2629206 --- /dev/null +++ b/DN_RGB/code/dataloader.py @@ -0,0 +1,158 @@ +import threading +import random + +import torch +import torch.multiprocessing as multiprocessing +from torch.utils.data import DataLoader +from torch.utils.data import SequentialSampler +from torch.utils.data import RandomSampler +from torch.utils.data import BatchSampler +from torch.utils.data import _utils +from torch.utils.data.dataloader import _DataLoaderIter + +from torch.utils.data._utils import collate +from torch.utils.data._utils import signal_handling +from torch.utils.data._utils import MP_STATUS_CHECK_INTERVAL +from torch.utils.data._utils import ExceptionWrapper +from torch.utils.data._utils import IS_WINDOWS +from torch.utils.data._utils.worker import ManagerWatchdog + +from torch._six import queue + +def _ms_loop(dataset, index_queue, data_queue, done_event, collate_fn, scale, seed, init_fn, worker_id): + try: + collate._use_shared_memory = True + signal_handling._set_worker_signal_handlers() + + torch.set_num_threads(1) + random.seed(seed) + torch.manual_seed(seed) + + data_queue.cancel_join_thread() + + if init_fn is not None: + init_fn(worker_id) + + watchdog = ManagerWatchdog() + + while watchdog.is_alive(): + try: + r = index_queue.get(timeout=MP_STATUS_CHECK_INTERVAL) + except queue.Empty: + continue + + if r is None: + assert done_event.is_set() + return + elif done_event.is_set(): + continue + + idx, batch_indices = r + try: + idx_scale = 0 + if len(scale) > 1 and dataset.train: + idx_scale = random.randrange(0, len(scale)) + dataset.set_scale(idx_scale) + + samples = collate_fn([dataset[i] for i in batch_indices]) + samples.append(idx_scale) + except Exception: + data_queue.put((idx, ExceptionWrapper(sys.exc_info()))) + else: + data_queue.put((idx, samples)) + del samples + + except KeyboardInterrupt: + pass + +class _MSDataLoaderIter(_DataLoaderIter): + + def __init__(self, loader): + self.dataset = loader.dataset + self.scale = loader.scale + self.collate_fn = loader.collate_fn + self.batch_sampler = loader.batch_sampler + self.num_workers = loader.num_workers + self.pin_memory = loader.pin_memory and torch.cuda.is_available() + self.timeout = loader.timeout + + self.sample_iter = iter(self.batch_sampler) + + base_seed = torch.LongTensor(1).random_().item() + + if self.num_workers > 0: + self.worker_init_fn = loader.worker_init_fn + self.worker_queue_idx = 0 + self.worker_result_queue = multiprocessing.Queue() + self.batches_outstanding = 0 + self.worker_pids_set = False + self.shutdown = False + self.send_idx = 0 + self.rcvd_idx = 0 + self.reorder_dict = {} + self.done_event = multiprocessing.Event() + + base_seed = torch.LongTensor(1).random_()[0] + + self.index_queues = [] + self.workers = [] + for i in range(self.num_workers): + index_queue = multiprocessing.Queue() + index_queue.cancel_join_thread() + w = multiprocessing.Process( + target=_ms_loop, + args=( + self.dataset, + index_queue, + self.worker_result_queue, + self.done_event, + self.collate_fn, + self.scale, + base_seed + i, + self.worker_init_fn, + i + ) + ) + w.daemon = True + w.start() + self.index_queues.append(index_queue) + self.workers.append(w) + + if self.pin_memory: + self.data_queue = queue.Queue() + pin_memory_thread = threading.Thread( + target=_utils.pin_memory._pin_memory_loop, + args=( + self.worker_result_queue, + self.data_queue, + torch.cuda.current_device(), + self.done_event + ) + ) + pin_memory_thread.daemon = True + pin_memory_thread.start() + self.pin_memory_thread = pin_memory_thread + else: + self.data_queue = self.worker_result_queue + + _utils.signal_handling._set_worker_pids( + id(self), tuple(w.pid for w in self.workers) + ) + _utils.signal_handling._set_SIGCHLD_handler() + self.worker_pids_set = True + + for _ in range(2 * self.num_workers): + self._put_indices() + + +class MSDataLoader(DataLoader): + + def __init__(self, cfg, *args, **kwargs): + super(MSDataLoader, self).__init__( + *args, **kwargs, num_workers=cfg.n_threads + ) + self.scale = cfg.scale + + def __iter__(self): + return _MSDataLoaderIter(self) + diff --git a/DN_RGB/code/demo.sb b/DN_RGB/code/demo.sb new file mode 100644 index 0000000000000000000000000000000000000000..0f875083c8818ab146b63a3e1cb8be1d9706ef9b --- /dev/null +++ b/DN_RGB/code/demo.sb @@ -0,0 +1,6 @@ +#!/bin/bash +# PANET Train +#python main.py --n_GPUs 1 --lr 1e-5 --batch_size 16 --save_models --epoch 100 --model PANET --scale 50 --patch_size 48 --reset --save MDSR_att_N50 --n_feats 64 --data_train DIV2K --chop + +#PANET Test +python main.py --model PANET --save_results --n_GPUs 1 --chop --data_test Kodak24+CBSD68+Urban100 --scale 10 --pre_train ../model_N10.pt --test_only diff --git a/DN_RGB/code/lambda_networks/__init__.py b/DN_RGB/code/lambda_networks/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f58c729ec677faaf96122272eb20d982210947fe --- /dev/null +++ b/DN_RGB/code/lambda_networks/__init__.py @@ -0,0 +1,4 @@ +from lambda_networks.lambda_networks import LambdaLayer +from lambda_networks.lambda_networks import Recursion +from lambda_networks.rlambda_networks import RLambdaLayer +λLayer = LambdaLayer \ No newline at end of file diff --git a/DN_RGB/code/lambda_networks/__pycache__/__init__.cpython-37.pyc b/DN_RGB/code/lambda_networks/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..17852428c03a0228af0c342d7a1474ac41127e20 Binary files /dev/null and b/DN_RGB/code/lambda_networks/__pycache__/__init__.cpython-37.pyc differ diff --git a/DN_RGB/code/lambda_networks/__pycache__/lambda_networks.cpython-37.pyc b/DN_RGB/code/lambda_networks/__pycache__/lambda_networks.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f3bb3767dfe787ad2901a7029134691d22061ff9 Binary files /dev/null and b/DN_RGB/code/lambda_networks/__pycache__/lambda_networks.cpython-37.pyc differ diff --git a/DN_RGB/code/lambda_networks/__pycache__/rlambda_networks.cpython-37.pyc b/DN_RGB/code/lambda_networks/__pycache__/rlambda_networks.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3f4039371b3ea0a02394401bd184d71dd83ca7bc Binary files /dev/null and b/DN_RGB/code/lambda_networks/__pycache__/rlambda_networks.cpython-37.pyc differ diff --git a/DN_RGB/code/lambda_networks/lambda_networks.py b/DN_RGB/code/lambda_networks/lambda_networks.py new file mode 100644 index 0000000000000000000000000000000000000000..97001975ab47b9fd717921183d995eee793908e9 --- /dev/null +++ b/DN_RGB/code/lambda_networks/lambda_networks.py @@ -0,0 +1,160 @@ +import torch +from torch import nn, einsum +import torch.nn.functional as F +from einops import rearrange + +# my layer normalization + +class LayerNorm(nn.Module): + def __init__(self, eps= 1e-5): + super(LayerNorm, self).__init__() + self.eps = eps + def forward(self, input): + shape=tuple(input.size()[1:]) + return F.layer_norm(input, shape, eps=self.eps) + def extra_repr(self): + return f'eps={self.eps}' + +# helpers functions +def exists(val): + return val is not None + +def default(val, d): + return val if exists(val) else d + +# lambda layer + +class LambdaLayer(nn.Module): + def __init__( + self, + dim, + *, + dim_k, + n = None, + r = None, + heads = 4, + dim_out = None, + dim_u = 1, + normalization="batch"): + super().__init__() + dim_out = default(dim_out, dim) + self.u = dim_u # intra-depth dimension + self.heads = heads + + assert (dim_out % heads) == 0, 'values dimension must be divisible by number of heads for multi-head query' + dim_v = dim_out // heads + + self.to_q = nn.Conv2d(dim, dim_k * heads, 1, bias = False) + self.to_k = nn.Conv2d(dim, dim_k * dim_u, 1, bias = False) + self.to_v = nn.Conv2d(dim, dim_v * dim_u, 1, bias = False) + print(f"using {normalization} in lambda layer") + if normalization=="none": + self.norm_q = nn.Identity(dim_k * heads) + self.norm_v = nn.Identity(dim_v * dim_u) + elif normalization=="instance": + self.norm_q = nn.InstanceNorm2d(dim_k * heads) + self.norm_v = nn.InstanceNorm2d(dim_v * dim_u) + elif normalization=="layer": + self.norm_q = LayerNorm() + self.norm_v = LayerNorm() + else: + self.norm_q = nn.BatchNorm2d(dim_k * heads) + self.norm_v = nn.BatchNorm2d(dim_v * dim_u) + print(f"using BN in lambda layer?") + + self.local_contexts = exists(r) + if exists(r): + assert (r % 2) == 1, 'Receptive kernel size should be odd' + self.pos_conv = nn.Conv3d(dim_u, dim_k, (1, r, r), padding = (0, r // 2, r // 2)) + else: + assert exists(n), 'You must specify the total sequence length (h x w)' + self.pos_emb = nn.Parameter(torch.randn(n, n, dim_k, dim_u)) + + + def forward(self, x): + b, c, hh, ww, u, h = *x.shape, self.u, self.heads + + q = self.to_q(x) + k = self.to_k(x) + v = self.to_v(x) + + q = self.norm_q(q) + v = self.norm_v(v) + + q = rearrange(q, 'b (h k) hh ww -> b h k (hh ww)', h = h) + k = rearrange(k, 'b (u k) hh ww -> b u k (hh ww)', u = u) + v = rearrange(v, 'b (u v) hh ww -> b u v (hh ww)', u = u) + + k = k.softmax(dim=-1) + + λc = einsum('b u k m, b u v m -> b k v', k, v) + Yc = einsum('b h k n, b k v -> b h v n', q, λc) + + if self.local_contexts: + v = rearrange(v, 'b u v (hh ww) -> b u v hh ww', hh = hh, ww = ww) + λp = self.pos_conv(v) + Yp = einsum('b h k n, b k v n -> b h v n', q, λp.flatten(3)) + else: + λp = einsum('n m k u, b u v m -> b n k v', self.pos_emb, v) + Yp = einsum('b h k n, b n k v -> b h v n', q, λp) + + Y = Yc + Yp + out = rearrange(Y, 'b h v (hh ww) -> b (h v) hh ww', hh = hh, ww = ww) + return out + + +# i'm not sure whether this will work or not +class Recursion(nn.Module): + def __init__(self, N: int, hidden_dim:int=64): + super(Recursion,self).__init__() + self.N = N + self.lambdaNxN_identity = LambdaLayer(dim=hidden_dim, dim_out=hidden_dim, n=N * N, dim_k=16, heads=2, dim_u=1) + # merge upstream information here + self.lambdaNxN_merge = LambdaLayer(dim=2*hidden_dim, dim_out=hidden_dim, n=N * N, dim_k=16, heads=2, dim_u=1) + self.downscale_conv = nn.Conv2d(hidden_dim, hidden_dim, kernel_size=N, stride=N) + self.upscale_conv = nn.Conv2d(hidden_dim, hidden_dim * N * N, kernel_size=3,padding=1) + self.pixel_shuffle = nn.PixelShuffle(N) + + def forward(self, x: torch.Tensor): + N = self.N + + def to_patch(blocks:torch.Tensor)->torch.Tensor: + shape = blocks.shape + blocks_patch = F.unfold(blocks, kernel_size=N, stride=N) + blocks_patch = blocks_patch.view(shape[0], shape[1], N, N, -1) + num_patch = blocks_patch.shape[-1] + blocks_patch = blocks_patch.permute(0, 4, 1, 2, 3).reshape(-1, shape[1], N, N).contiguous() + return blocks_patch, num_patch + + def combine_patch(processed_patch,shape,num_patch): + processed_patch = processed_patch.reshape(shape[0], num_patch, shape[1], N, N) + processed_patch=processed_patch.permute(0, 2, 3, 4, 1).reshape(shape[0],shape[1] * N * N,num_patch).contiguous() + processed=F.fold(processed_patch,output_size=(shape[-2],shape[-1]),kernel_size=N,stride=N) + return processed + + def process(blocks:torch.Tensor)->torch.Tensor: + shape = blocks.shape + if blocks.shape[-1] == N: + processed = self.lambdaNxN_identity(blocks) + return processed + # to NxN patchs + blocks_patch,num_patch=to_patch(blocks) + # pass through identity + processed_patch = self.lambdaNxN_identity(blocks_patch) + # back to HxW + processed=combine_patch(processed_patch,shape,num_patch) + # get feedback + feedback = process(self.downscale_conv(processed)) + # upscale feedback + upscale_feedback = self.upscale_conv(feedback) + upscale_feedback=self.pixel_shuffle(upscale_feedback) + # combine results + combined = torch.cat([processed, upscale_feedback], dim=1) + combined_shape=combined.shape + combined_patch,num_patch=to_patch(combined) + combined_patch_reduced = self.lambdaNxN_merge(combined_patch) + ret_shape=(combined_shape[0],combined_shape[1]//2,combined_shape[2],combined_shape[3]) + ret=combine_patch(combined_patch_reduced,ret_shape,num_patch) + return ret + + return process(x) \ No newline at end of file diff --git a/DN_RGB/code/lambda_networks/rlambda_networks.py b/DN_RGB/code/lambda_networks/rlambda_networks.py new file mode 100644 index 0000000000000000000000000000000000000000..49f9a0ce799ac80bae1279a42cd574cddcae205e --- /dev/null +++ b/DN_RGB/code/lambda_networks/rlambda_networks.py @@ -0,0 +1,93 @@ +import torch +from torch import nn, einsum +import torch.nn.functional as F +from einops import rearrange + + +# helpers functions + +def exists(val): + return val is not None + + +def default(val, d): + return val if exists(val) else d + + +# lambda layer + +class RLambdaLayer(nn.Module): + def __init__( + self, + dim, + *, + dim_k, + n=None, + r=None, + heads=4, + dim_out=None, + dim_u=1, + recurrence=None + ): + super().__init__() + dim_out = default(dim_out, dim) + self.u = dim_u # intra-depth dimension + self.heads = heads + + assert (dim_out % heads) == 0, 'values dimension must be divisible by number of heads for multi-head query' + dim_v = dim_out // heads + + self.to_q = nn.Conv2d(dim, dim_k * heads, 1, bias=False) + self.to_k = nn.Conv2d(dim, dim_k * dim_u, 1, bias=False) + self.to_v = nn.Conv2d(dim, dim_v * dim_u, 1, bias=False) + + self.norm_q = nn.BatchNorm2d(dim_k * heads) + self.norm_v = nn.BatchNorm2d(dim_v * dim_u) + + self.local_contexts = exists(r) + self.recurrence = recurrence + if exists(r): + assert (r % 2) == 1, 'Receptive kernel size should be odd' + self.pos_conv = nn.Conv3d(dim_u, dim_k, (1, r, r), padding=(0, r // 2, r // 2)) + else: + assert exists(n), 'You must specify the total sequence length (h x w)' + self.pos_emb = nn.Parameter(torch.randn(n, n, dim_k, dim_u)) + + def apply_lambda(self, lambda_c, lambda_p, x): + b, c, hh, ww, u, h = *x.shape, self.u, self.heads + q = self.to_q(x) + q = self.norm_q(q) + q = rearrange(q, 'b (h k) hh ww -> b h k (hh ww)', h=h) + Yc = einsum('b h k n, b k v -> b h v n', q, lambda_c) + if self.local_contexts: + Yp = einsum('b h k n, b k v n -> b h v n', q, lambda_p.flatten(3)) + else: + Yp = einsum('b h k n, b n k v -> b h v n', q, lambda_p) + Y = Yc + Yp + out = rearrange(Y, 'b h v (hh ww) -> b (h v) hh ww', hh=hh, ww=ww) + return out + + def forward(self, x): + b, c, hh, ww, u, h = *x.shape, self.u, self.heads + + k = self.to_k(x) + v = self.to_v(x) + + v = self.norm_v(v) + + k = rearrange(k, 'b (u k) hh ww -> b u k (hh ww)', u=u) + v = rearrange(v, 'b (u v) hh ww -> b u v (hh ww)', u=u) + + k = k.softmax(dim=-1) + + λc = einsum('b u k m, b u v m -> b k v', k, v) + + if self.local_contexts: + v = rearrange(v, 'b u v (hh ww) -> b u v hh ww', hh=hh, ww=ww) + λp = self.pos_conv(v) + else: + λp = einsum('n m k u, b u v m -> b n k v', self.pos_emb, v) + out = x + for i in range(self.recurrence): + out = self.apply_lambda(λc, λp, out) + return out diff --git a/DN_RGB/code/loss/__init__.py b/DN_RGB/code/loss/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b67e2044a11a4f6a7d7aa143f34c64837d0dc7f4 --- /dev/null +++ b/DN_RGB/code/loss/__init__.py @@ -0,0 +1,174 @@ +import os +from importlib import import_module + +import matplotlib +matplotlib.use('Agg') +import matplotlib.pyplot as plt + +import numpy as np + +import torch +import torch.nn as nn +import torch.nn.functional as F + +def sequence_loss(sr, hr, loss_func, gamma=0.8, max_val=None): + """ Loss function defined over sequence of flow predictions """ + + n_recurrence = len(sr) + total_loss = 0.0 + buffer=[0.0]*n_recurrence + # exlude invalid pixels and extremely large diplacements + for i in range(n_recurrence): + i_weight = gamma**(n_recurrence - i - 1) + i_loss = loss_func(sr[i],hr) + buffer[i]=i_loss.item() + # total_loss += i_weight * (valid[:, None] * i_loss).mean() + total_loss += i_weight * (i_loss) + return total_loss,buffer + +class Loss(nn.modules.loss._Loss): + def __init__(self, args, ckp): + super(Loss, self).__init__() + print('Preparing loss function:') + self.buffer=[0.0]*args.recurrence + self.n_GPUs = args.n_GPUs + self.loss = [] + self.decay_gamma=args.decay_gamma + self.loss_module = nn.ModuleList() + for loss in args.loss.split('+'): + weight, loss_type = loss.split('*') + if loss_type == 'MSE': + loss_function = nn.MSELoss() + elif loss_type == 'L1': + loss_function = nn.L1Loss() + elif loss_type.find('VGG') >= 0: + module = import_module('loss.vgg') + loss_function = getattr(module, 'VGG')( + loss_type[3:], + rgb_range=args.rgb_range + ) + elif loss_type.find('GAN') >= 0: + module = import_module('loss.adversarial') + loss_function = getattr(module, 'Adversarial')( + args, + loss_type + ) + + self.loss.append({ + 'type': loss_type, + 'weight': float(weight), + 'function': loss_function} + ) + if loss_type.find('GAN') >= 0: + self.loss.append({'type': 'DIS', 'weight': 1, 'function': None}) + + if len(self.loss) > 1: + self.loss.append({'type': 'Total', 'weight': 0, 'function': None}) + + for l in self.loss: + if l['function'] is not None: + print('{:.3f} * {}'.format(l['weight'], l['type'])) + # self.loss_module.append(l['function']) + + self.log = torch.Tensor() + + device = torch.device('cpu' if args.cpu else 'cuda') + self.loss_module.to(device) + if args.precision == 'half': self.loss_module.half() + if not args.cpu and args.n_GPUs > 1: + self.loss_module = nn.DataParallel( + self.loss_module, range(args.n_GPUs) + ) + + if args.load != '': self.load(ckp.dir, cpu=args.cpu) + + def forward(self, sr, hr): + losses = [] + for i, l in enumerate(self.loss): + if l['function'] is not None: + if isinstance(sr,list): + # weights=[0.32,0.08,0.02,0.01,0.005] + # weights=weights[::-1] + # weights=[0.01,0.02,0.08,0.32] + # self.buffer=[] + effective_loss,buffer_lst=sequence_loss(sr,hr,l['function'],gamma=self.decay_gamma) + # for k in range(len(sr)): + # loss=l['function'](sr[k], hr) + # self.buffer.append(loss.item()) + # effective_loss=loss*weights[k]*l['weight'] + losses.append(effective_loss) + self.buffer=buffer_lst + self.log[-1, i] += effective_loss.item() + else: + loss = l['function'](sr, hr) + effective_loss = l['weight'] * loss + losses.append(effective_loss) + self.buffer[0]=effective_loss.item() + self.log[-1, i] += effective_loss.item() + elif l['type'] == 'DIS': + self.log[-1, i] += self.loss[i - 1]['function'].loss + + loss_sum = sum(losses) + if len(self.loss) > 1: + self.log[-1, -1] += loss_sum.item() + + return loss_sum + + def step(self): + for l in self.get_loss_module(): + if hasattr(l, 'scheduler'): + l.scheduler.step() + + def start_log(self): + self.log = torch.cat((self.log, torch.zeros(1, len(self.loss)))) + + def end_log(self, n_batches): + self.log[-1].div_(n_batches) + + def display_loss(self, batch): + n_samples = batch + 1 + log = [] + for l, c in zip(self.loss, self.log[-1]): + log.append('[{}: {:.4f}]'.format(l['type'], c / n_samples)) + + return ''.join(log) + + def plot_loss(self, apath, epoch): + axis = np.linspace(1, epoch, epoch) + for i, l in enumerate(self.loss): + label = '{} Loss'.format(l['type']) + fig = plt.figure() + plt.title(label) + plt.plot(axis, self.log[:, i].numpy(), label=label) + plt.legend() + plt.xlabel('Epochs') + plt.ylabel('Loss') + plt.grid(True) + plt.savefig(os.path.join(apath, 'loss_{}.pdf'.format(l['type']))) + plt.close(fig) + + def get_loss_module(self): + if self.n_GPUs == 1: + return self.loss_module + else: + return self.loss_module.module + + def save(self, apath): + torch.save(self.state_dict(), os.path.join(apath, 'loss.pt')) + torch.save(self.log, os.path.join(apath, 'loss_log.pt')) + + def load(self, apath, cpu=False): + if cpu: + kwargs = {'map_location': lambda storage, loc: storage} + else: + kwargs = {} + + self.load_state_dict(torch.load( + os.path.join(apath, 'loss.pt'), + **kwargs + )) + self.log = torch.load(os.path.join(apath, 'loss_log.pt')) + for l in self.get_loss_module(): + if hasattr(l, 'scheduler'): + for _ in range(len(self.log)): l.scheduler.step() + diff --git a/DN_RGB/code/loss/__pycache__/__init__.cpython-36.pyc b/DN_RGB/code/loss/__pycache__/__init__.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2aab39f57ed6e6c55d57dc073281dd51eddfa016 Binary files /dev/null and b/DN_RGB/code/loss/__pycache__/__init__.cpython-36.pyc differ diff --git a/DN_RGB/code/loss/__pycache__/__init__.cpython-37.pyc b/DN_RGB/code/loss/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e917f9db3c1f44a5bb54c5aa3f88bd386500a5db Binary files /dev/null and b/DN_RGB/code/loss/__pycache__/__init__.cpython-37.pyc differ diff --git a/DN_RGB/code/loss/adversarial.py b/DN_RGB/code/loss/adversarial.py new file mode 100644 index 0000000000000000000000000000000000000000..db930a8efbd040b3a2271b20193194a58646086d --- /dev/null +++ b/DN_RGB/code/loss/adversarial.py @@ -0,0 +1,112 @@ +import utility +from types import SimpleNamespace + +from model import common +from loss import discriminator + +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.optim as optim + +class Adversarial(nn.Module): + def __init__(self, args, gan_type): + super(Adversarial, self).__init__() + self.gan_type = gan_type + self.gan_k = args.gan_k + self.dis = discriminator.Discriminator(args) + if gan_type == 'WGAN_GP': + # see https://arxiv.org/pdf/1704.00028.pdf pp.4 + optim_dict = { + 'optimizer': 'ADAM', + 'betas': (0, 0.9), + 'epsilon': 1e-8, + 'lr': 1e-5, + 'weight_decay': args.weight_decay, + 'decay': args.decay, + 'gamma': args.gamma + } + optim_args = SimpleNamespace(**optim_dict) + else: + optim_args = args + + self.optimizer = utility.make_optimizer(optim_args, self.dis) + + def forward(self, fake, real): + # updating discriminator... + self.loss = 0 + fake_detach = fake.detach() # do not backpropagate through G + for _ in range(self.gan_k): + self.optimizer.zero_grad() + # d: B x 1 tensor + d_fake = self.dis(fake_detach) + d_real = self.dis(real) + retain_graph = False + if self.gan_type == 'GAN': + loss_d = self.bce(d_real, d_fake) + elif self.gan_type.find('WGAN') >= 0: + loss_d = (d_fake - d_real).mean() + if self.gan_type.find('GP') >= 0: + epsilon = torch.rand_like(fake).view(-1, 1, 1, 1) + hat = fake_detach.mul(1 - epsilon) + real.mul(epsilon) + hat.requires_grad = True + d_hat = self.dis(hat) + gradients = torch.autograd.grad( + outputs=d_hat.sum(), inputs=hat, + retain_graph=True, create_graph=True, only_inputs=True + )[0] + gradients = gradients.view(gradients.size(0), -1) + gradient_norm = gradients.norm(2, dim=1) + gradient_penalty = 10 * gradient_norm.sub(1).pow(2).mean() + loss_d += gradient_penalty + # from ESRGAN: Enhanced Super-Resolution Generative Adversarial Networks + elif self.gan_type == 'RGAN': + better_real = d_real - d_fake.mean(dim=0, keepdim=True) + better_fake = d_fake - d_real.mean(dim=0, keepdim=True) + loss_d = self.bce(better_real, better_fake) + retain_graph = True + + # Discriminator update + self.loss += loss_d.item() + loss_d.backward(retain_graph=retain_graph) + self.optimizer.step() + + if self.gan_type == 'WGAN': + for p in self.dis.parameters(): + p.data.clamp_(-1, 1) + + self.loss /= self.gan_k + + # updating generator... + d_fake_bp = self.dis(fake) # for backpropagation, use fake as it is + if self.gan_type == 'GAN': + label_real = torch.ones_like(d_fake_bp) + loss_g = F.binary_cross_entropy_with_logits(d_fake_bp, label_real) + elif self.gan_type.find('WGAN') >= 0: + loss_g = -d_fake_bp.mean() + elif self.gan_type == 'RGAN': + better_real = d_real - d_fake_bp.mean(dim=0, keepdim=True) + better_fake = d_fake_bp - d_real.mean(dim=0, keepdim=True) + loss_g = self.bce(better_fake, better_real) + + # Generator loss + return loss_g + + def state_dict(self, *args, **kwargs): + state_discriminator = self.dis.state_dict(*args, **kwargs) + state_optimizer = self.optimizer.state_dict() + + return dict(**state_discriminator, **state_optimizer) + + def bce(self, real, fake): + label_real = torch.ones_like(real) + label_fake = torch.zeros_like(fake) + bce_real = F.binary_cross_entropy_with_logits(real, label_real) + bce_fake = F.binary_cross_entropy_with_logits(fake, label_fake) + bce_loss = bce_real + bce_fake + return bce_loss + +# Some references +# https://github.com/kuc2477/pytorch-wgan-gp/blob/master/model.py +# OR +# https://github.com/caogang/wgan-gp/blob/master/gan_cifar10.py diff --git a/DN_RGB/code/loss/discriminator.py b/DN_RGB/code/loss/discriminator.py new file mode 100644 index 0000000000000000000000000000000000000000..05469d37865fe79642e61fb71d479b96d1688ba4 --- /dev/null +++ b/DN_RGB/code/loss/discriminator.py @@ -0,0 +1,55 @@ +from model import common + +import torch.nn as nn + +class Discriminator(nn.Module): + ''' + output is not normalized + ''' + def __init__(self, args): + super(Discriminator, self).__init__() + + in_channels = args.n_colors + out_channels = 64 + depth = 7 + + def _block(_in_channels, _out_channels, stride=1): + return nn.Sequential( + nn.Conv2d( + _in_channels, + _out_channels, + 3, + padding=1, + stride=stride, + bias=False + ), + nn.BatchNorm2d(_out_channels), + nn.LeakyReLU(negative_slope=0.2, inplace=True) + ) + + m_features = [_block(in_channels, out_channels)] + for i in range(depth): + in_channels = out_channels + if i % 2 == 1: + stride = 1 + out_channels *= 2 + else: + stride = 2 + m_features.append(_block(in_channels, out_channels, stride=stride)) + + patch_size = args.patch_size // (2**((depth + 1) // 2)) + m_classifier = [ + nn.Linear(out_channels * patch_size**2, 1024), + nn.LeakyReLU(negative_slope=0.2, inplace=True), + nn.Linear(1024, 1) + ] + + self.features = nn.Sequential(*m_features) + self.classifier = nn.Sequential(*m_classifier) + + def forward(self, x): + features = self.features(x) + output = self.classifier(features.view(features.size(0), -1)) + + return output + diff --git a/DN_RGB/code/loss/vgg.py b/DN_RGB/code/loss/vgg.py new file mode 100644 index 0000000000000000000000000000000000000000..f8391bd6e8aeab1f31fd5d4ca4abbd3da0eaba71 --- /dev/null +++ b/DN_RGB/code/loss/vgg.py @@ -0,0 +1,36 @@ +from model import common + +import torch +import torch.nn as nn +import torch.nn.functional as F +import torchvision.models as models + +class VGG(nn.Module): + def __init__(self, conv_index, rgb_range=1): + super(VGG, self).__init__() + vgg_features = models.vgg19(pretrained=True).features + modules = [m for m in vgg_features] + if conv_index.find('22') >= 0: + self.vgg = nn.Sequential(*modules[:8]) + elif conv_index.find('54') >= 0: + self.vgg = nn.Sequential(*modules[:35]) + + vgg_mean = (0.485, 0.456, 0.406) + vgg_std = (0.229 * rgb_range, 0.224 * rgb_range, 0.225 * rgb_range) + self.sub_mean = common.MeanShift(rgb_range, vgg_mean, vgg_std) + for p in self.parameters(): + p.requires_grad = False + + def forward(self, sr, hr): + def _forward(x): + x = self.sub_mean(x) + x = self.vgg(x) + return x + + vgg_sr = _forward(sr) + with torch.no_grad(): + vgg_hr = _forward(hr.detach()) + + loss = F.mse_loss(vgg_sr, vgg_hr) + + return loss diff --git a/DN_RGB/code/main.py b/DN_RGB/code/main.py new file mode 100644 index 0000000000000000000000000000000000000000..9703700d795fc061f82b80603d9ffee9f870dc51 --- /dev/null +++ b/DN_RGB/code/main.py @@ -0,0 +1,35 @@ +import torch + +import utility +import data +import model +import loss +from option import args +from trainer import Trainer + +torch.manual_seed(args.seed) +checkpoint = utility.checkpoint(args) + +def main(): + global model + if args.data_test == ['video']: + from videotester import VideoTester + model = model.Model(args,checkpoint) + print('total params: %.2fM' % (sum(p.numel() for p in model.parameters())/1000000.0)) + t = VideoTester(args, model, checkpoint) + t.test() + else: + if checkpoint.ok: + loader = data.Data(args) + _model = model.Model(args, checkpoint) + print('total params:%.5fM' % (sum(p.numel() for p in _model.parameters())/1000000.0)) + _loss = loss.Loss(args, checkpoint) if not args.test_only else None + t = Trainer(args, loader, _model, _loss, checkpoint) + while not t.terminate(): + t.train() + t.test() + + checkpoint.done() + +if __name__ == '__main__': + main() diff --git a/DN_RGB/code/model/.ipynb_checkpoints/__init__-checkpoint.py b/DN_RGB/code/model/.ipynb_checkpoints/__init__-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..e405b3c93b263a149fb446e88c0a3b56a9341691 --- /dev/null +++ b/DN_RGB/code/model/.ipynb_checkpoints/__init__-checkpoint.py @@ -0,0 +1,190 @@ +import os +from importlib import import_module + +import torch +import torch.nn as nn +from torch.autograd import Variable + +class Model(nn.Module): + def __init__(self, args, ckp): + super(Model, self).__init__() + print('Making model...') + + self.scale = args.scale + self.idx_scale = 0 + self.self_ensemble = args.self_ensemble + self.chop = args.chop + self.precision = args.precision + self.cpu = args.cpu + self.device = torch.device('cpu' if args.cpu else 'cuda') + self.n_GPUs = args.n_GPUs + self.save_models = args.save_models + + module = import_module('model.' + args.model.lower()) + self.model = module.make_model(args).to(self.device) + if args.precision == 'half': self.model.half() + + if not args.cpu and args.n_GPUs > 1: + self.model = nn.DataParallel(self.model, range(args.n_GPUs)) + + self.load( + ckp.dir, + pre_train=args.pre_train, + resume=args.resume, + cpu=args.cpu + ) + print(self.model, file=ckp.log_file) + + def forward(self, x, idx_scale): + self.idx_scale = idx_scale + target = self.get_model() + if hasattr(target, 'set_scale'): + target.set_scale(idx_scale) + + if self.self_ensemble and not self.training: + if self.chop: + forward_function = self.forward_chop + else: + forward_function = self.model.forward + + return self.forward_x8(x, forward_function) + elif self.chop and not self.training: + return self.forward_chop(x) + else: + return self.model(x) + + def get_model(self): + if self.n_GPUs == 1: + return self.model + else: + return self.model.module + + def state_dict(self, **kwargs): + target = self.get_model() + return target.state_dict(**kwargs) + + def save(self, apath, epoch, is_best=False): + target = self.get_model() + torch.save( + target.state_dict(), + os.path.join(apath, 'model_latest.pt') + ) + if is_best: + torch.save( + target.state_dict(), + os.path.join(apath, 'model_best.pt') + ) + + if self.save_models: + torch.save( + target.state_dict(), + os.path.join(apath, 'model_{}.pt'.format(epoch)) + ) + + def load(self, apath, pre_train='.', resume=-1, cpu=False): + if cpu: + kwargs = {'map_location': lambda storage, loc: storage} + else: + kwargs = {} + + if resume == -1: + self.get_model().load_state_dict( + torch.load( + os.path.join(apath,'model', 'model_latest.pt'), + **kwargs + ), + strict=False + ) + elif resume == 0: + if pre_train != '.': + print('Loading model from {}'.format(pre_train)) + self.get_model().load_state_dict( + torch.load(pre_train, **kwargs), + strict=False + ) + else: + self.get_model().load_state_dict( + torch.load( + os.path.join(apath, 'model', 'model_{}.pt'.format(resume)), + **kwargs + ), + strict=False + ) + + def forward_chop(self, x, shave=10, min_size=6800): + scale = self.scale[self.idx_scale] + scale = 1 + n_GPUs = min(self.n_GPUs, 4) + b, c, h, w = x.size() + h_half, w_half = h // 2, w // 2 + h_size, w_size = h_half + shave, w_half + shave + lr_list = [ + x[:, :, 0:h_size, 0:w_size], + x[:, :, 0:h_size, (w - w_size):w], + x[:, :, (h - h_size):h, 0:w_size], + x[:, :, (h - h_size):h, (w - w_size):w]] + + if w_size * h_size < min_size: + sr_list = [] + for i in range(0, 4, n_GPUs): + lr_batch = torch.cat(lr_list[i:(i + n_GPUs)], dim=0) + sr_batch = self.model(lr_batch) + sr_list.extend(sr_batch.chunk(n_GPUs, dim=0)) + else: + sr_list = [ + self.forward_chop(patch, shave=shave, min_size=min_size) \ + for patch in lr_list + ] + + h, w = scale * h, scale * w + h_half, w_half = scale * h_half, scale * w_half + h_size, w_size = scale * h_size, scale * w_size + shave *= scale + + output = x.new(b, c, h, w) + output[:, :, 0:h_half, 0:w_half] \ + = sr_list[0][:, :, 0:h_half, 0:w_half] + output[:, :, 0:h_half, w_half:w] \ + = sr_list[1][:, :, 0:h_half, (w_size - w + w_half):w_size] + output[:, :, h_half:h, 0:w_half] \ + = sr_list[2][:, :, (h_size - h + h_half):h_size, 0:w_half] + output[:, :, h_half:h, w_half:w] \ + = sr_list[3][:, :, (h_size - h + h_half):h_size, (w_size - w + w_half):w_size] + + return output + + def forward_x8(self, x, forward_function): + def _transform(v, op): + if self.precision != 'single': v = v.float() + + v2np = v.data.cpu().numpy() + if op == 'v': + tfnp = v2np[:, :, :, ::-1].copy() + elif op == 'h': + tfnp = v2np[:, :, ::-1, :].copy() + elif op == 't': + tfnp = v2np.transpose((0, 1, 3, 2)).copy() + + ret = torch.Tensor(tfnp).to(self.device) + if self.precision == 'half': ret = ret.half() + + return ret + + lr_list = [x] + for tf in 'v', 'h', 't': + lr_list.extend([_transform(t, tf) for t in lr_list]) + + sr_list = [forward_function(aug) for aug in lr_list] + for i in range(len(sr_list)): + if i > 3: + sr_list[i] = _transform(sr_list[i], 't') + if i % 4 > 1: + sr_list[i] = _transform(sr_list[i], 'h') + if (i % 4) % 2 == 1: + sr_list[i] = _transform(sr_list[i], 'v') + + output_cat = torch.cat(sr_list, dim=0) + output = output_cat.mean(dim=0, keepdim=True) + + return output + diff --git a/DN_RGB/code/model/LICENSE b/DN_RGB/code/model/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..df2326a5dce9106825799c73dfab581cbde1f96c --- /dev/null +++ b/DN_RGB/code/model/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 Sanghyun Son + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/DN_RGB/code/model/__init__.py b/DN_RGB/code/model/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e405b3c93b263a149fb446e88c0a3b56a9341691 --- /dev/null +++ b/DN_RGB/code/model/__init__.py @@ -0,0 +1,190 @@ +import os +from importlib import import_module + +import torch +import torch.nn as nn +from torch.autograd import Variable + +class Model(nn.Module): + def __init__(self, args, ckp): + super(Model, self).__init__() + print('Making model...') + + self.scale = args.scale + self.idx_scale = 0 + self.self_ensemble = args.self_ensemble + self.chop = args.chop + self.precision = args.precision + self.cpu = args.cpu + self.device = torch.device('cpu' if args.cpu else 'cuda') + self.n_GPUs = args.n_GPUs + self.save_models = args.save_models + + module = import_module('model.' + args.model.lower()) + self.model = module.make_model(args).to(self.device) + if args.precision == 'half': self.model.half() + + if not args.cpu and args.n_GPUs > 1: + self.model = nn.DataParallel(self.model, range(args.n_GPUs)) + + self.load( + ckp.dir, + pre_train=args.pre_train, + resume=args.resume, + cpu=args.cpu + ) + print(self.model, file=ckp.log_file) + + def forward(self, x, idx_scale): + self.idx_scale = idx_scale + target = self.get_model() + if hasattr(target, 'set_scale'): + target.set_scale(idx_scale) + + if self.self_ensemble and not self.training: + if self.chop: + forward_function = self.forward_chop + else: + forward_function = self.model.forward + + return self.forward_x8(x, forward_function) + elif self.chop and not self.training: + return self.forward_chop(x) + else: + return self.model(x) + + def get_model(self): + if self.n_GPUs == 1: + return self.model + else: + return self.model.module + + def state_dict(self, **kwargs): + target = self.get_model() + return target.state_dict(**kwargs) + + def save(self, apath, epoch, is_best=False): + target = self.get_model() + torch.save( + target.state_dict(), + os.path.join(apath, 'model_latest.pt') + ) + if is_best: + torch.save( + target.state_dict(), + os.path.join(apath, 'model_best.pt') + ) + + if self.save_models: + torch.save( + target.state_dict(), + os.path.join(apath, 'model_{}.pt'.format(epoch)) + ) + + def load(self, apath, pre_train='.', resume=-1, cpu=False): + if cpu: + kwargs = {'map_location': lambda storage, loc: storage} + else: + kwargs = {} + + if resume == -1: + self.get_model().load_state_dict( + torch.load( + os.path.join(apath,'model', 'model_latest.pt'), + **kwargs + ), + strict=False + ) + elif resume == 0: + if pre_train != '.': + print('Loading model from {}'.format(pre_train)) + self.get_model().load_state_dict( + torch.load(pre_train, **kwargs), + strict=False + ) + else: + self.get_model().load_state_dict( + torch.load( + os.path.join(apath, 'model', 'model_{}.pt'.format(resume)), + **kwargs + ), + strict=False + ) + + def forward_chop(self, x, shave=10, min_size=6800): + scale = self.scale[self.idx_scale] + scale = 1 + n_GPUs = min(self.n_GPUs, 4) + b, c, h, w = x.size() + h_half, w_half = h // 2, w // 2 + h_size, w_size = h_half + shave, w_half + shave + lr_list = [ + x[:, :, 0:h_size, 0:w_size], + x[:, :, 0:h_size, (w - w_size):w], + x[:, :, (h - h_size):h, 0:w_size], + x[:, :, (h - h_size):h, (w - w_size):w]] + + if w_size * h_size < min_size: + sr_list = [] + for i in range(0, 4, n_GPUs): + lr_batch = torch.cat(lr_list[i:(i + n_GPUs)], dim=0) + sr_batch = self.model(lr_batch) + sr_list.extend(sr_batch.chunk(n_GPUs, dim=0)) + else: + sr_list = [ + self.forward_chop(patch, shave=shave, min_size=min_size) \ + for patch in lr_list + ] + + h, w = scale * h, scale * w + h_half, w_half = scale * h_half, scale * w_half + h_size, w_size = scale * h_size, scale * w_size + shave *= scale + + output = x.new(b, c, h, w) + output[:, :, 0:h_half, 0:w_half] \ + = sr_list[0][:, :, 0:h_half, 0:w_half] + output[:, :, 0:h_half, w_half:w] \ + = sr_list[1][:, :, 0:h_half, (w_size - w + w_half):w_size] + output[:, :, h_half:h, 0:w_half] \ + = sr_list[2][:, :, (h_size - h + h_half):h_size, 0:w_half] + output[:, :, h_half:h, w_half:w] \ + = sr_list[3][:, :, (h_size - h + h_half):h_size, (w_size - w + w_half):w_size] + + return output + + def forward_x8(self, x, forward_function): + def _transform(v, op): + if self.precision != 'single': v = v.float() + + v2np = v.data.cpu().numpy() + if op == 'v': + tfnp = v2np[:, :, :, ::-1].copy() + elif op == 'h': + tfnp = v2np[:, :, ::-1, :].copy() + elif op == 't': + tfnp = v2np.transpose((0, 1, 3, 2)).copy() + + ret = torch.Tensor(tfnp).to(self.device) + if self.precision == 'half': ret = ret.half() + + return ret + + lr_list = [x] + for tf in 'v', 'h', 't': + lr_list.extend([_transform(t, tf) for t in lr_list]) + + sr_list = [forward_function(aug) for aug in lr_list] + for i in range(len(sr_list)): + if i > 3: + sr_list[i] = _transform(sr_list[i], 't') + if i % 4 > 1: + sr_list[i] = _transform(sr_list[i], 'h') + if (i % 4) % 2 == 1: + sr_list[i] = _transform(sr_list[i], 'v') + + output_cat = torch.cat(sr_list, dim=0) + output = output_cat.mean(dim=0, keepdim=True) + + return output + diff --git a/DN_RGB/code/model/__pycache__/__init__.cpython-36.pyc b/DN_RGB/code/model/__pycache__/__init__.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3bc02b70c3b41b38a9362768301c68b057f37eb4 Binary files /dev/null and b/DN_RGB/code/model/__pycache__/__init__.cpython-36.pyc differ diff --git a/DN_RGB/code/model/__pycache__/__init__.cpython-37.pyc b/DN_RGB/code/model/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..30410de9869b89f7a54a611393eb5809d2e2458b Binary files /dev/null and b/DN_RGB/code/model/__pycache__/__init__.cpython-37.pyc differ diff --git a/DN_RGB/code/model/__pycache__/attention.cpython-36.pyc b/DN_RGB/code/model/__pycache__/attention.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d8bb4875fbb0d93793ba304f999217af7f22eff4 Binary files /dev/null and b/DN_RGB/code/model/__pycache__/attention.cpython-36.pyc differ diff --git a/DN_RGB/code/model/__pycache__/attention.cpython-37.pyc b/DN_RGB/code/model/__pycache__/attention.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..334acf02356b973b4d84aff3e4174e0656ed06c7 Binary files /dev/null and b/DN_RGB/code/model/__pycache__/attention.cpython-37.pyc differ diff --git a/DN_RGB/code/model/__pycache__/common.cpython-36.pyc b/DN_RGB/code/model/__pycache__/common.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3a020e95f42d0d3bccaea757cab813c4a371d22c Binary files /dev/null and b/DN_RGB/code/model/__pycache__/common.cpython-36.pyc differ diff --git a/DN_RGB/code/model/__pycache__/common.cpython-37.pyc b/DN_RGB/code/model/__pycache__/common.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d21a90244d3bc021adfb444dbf0cd9f0312d8d4a Binary files /dev/null and b/DN_RGB/code/model/__pycache__/common.cpython-37.pyc differ diff --git a/DN_RGB/code/model/__pycache__/edsr.cpython-36.pyc b/DN_RGB/code/model/__pycache__/edsr.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8502f2a60b74c4bebe9caaf4134d7c86056f37ae Binary files /dev/null and b/DN_RGB/code/model/__pycache__/edsr.cpython-36.pyc differ diff --git a/DN_RGB/code/model/__pycache__/edsr2.cpython-36.pyc b/DN_RGB/code/model/__pycache__/edsr2.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..be43cbbc3eb79650d3e78672329f0bff2910a04b Binary files /dev/null and b/DN_RGB/code/model/__pycache__/edsr2.cpython-36.pyc differ diff --git a/DN_RGB/code/model/__pycache__/edsrl1.cpython-36.pyc b/DN_RGB/code/model/__pycache__/edsrl1.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fa7e464306842b7e2e76fa66d837c1f95435aa7e Binary files /dev/null and b/DN_RGB/code/model/__pycache__/edsrl1.cpython-36.pyc differ diff --git a/DN_RGB/code/model/__pycache__/edsrl1t.cpython-36.pyc b/DN_RGB/code/model/__pycache__/edsrl1t.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..74dc72f423fb1c196978c76725c50b9d2ad732b0 Binary files /dev/null and b/DN_RGB/code/model/__pycache__/edsrl1t.cpython-36.pyc differ diff --git a/DN_RGB/code/model/__pycache__/grunet.cpython-37.pyc b/DN_RGB/code/model/__pycache__/grunet.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1c1af85bcdb2f89ae8f57ae50571a1f9e99a920a Binary files /dev/null and b/DN_RGB/code/model/__pycache__/grunet.cpython-37.pyc differ diff --git a/DN_RGB/code/model/__pycache__/mssr.cpython-36.pyc b/DN_RGB/code/model/__pycache__/mssr.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eb750dc6f7604357e30145d37c9e33f466931a16 Binary files /dev/null and b/DN_RGB/code/model/__pycache__/mssr.cpython-36.pyc differ diff --git a/DN_RGB/code/model/__pycache__/panet.cpython-36.pyc b/DN_RGB/code/model/__pycache__/panet.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5cc8366a2da3bc5a74b74a505b102ca909ddc561 Binary files /dev/null and b/DN_RGB/code/model/__pycache__/panet.cpython-36.pyc differ diff --git a/DN_RGB/code/model/__pycache__/raftnets.cpython-37.pyc b/DN_RGB/code/model/__pycache__/raftnets.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7e4fa6bf9d33292441cb9040d8dbe66a48cef170 Binary files /dev/null and b/DN_RGB/code/model/__pycache__/raftnets.cpython-37.pyc differ diff --git a/DN_RGB/code/model/__pycache__/raftnetsingle.cpython-37.pyc b/DN_RGB/code/model/__pycache__/raftnetsingle.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d7c211699e8d763dc486eb4b0617d8fd7e592a42 Binary files /dev/null and b/DN_RGB/code/model/__pycache__/raftnetsingle.cpython-37.pyc differ diff --git a/DN_RGB/code/model/__pycache__/raftnetsnores.cpython-37.pyc b/DN_RGB/code/model/__pycache__/raftnetsnores.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8cbb07b8ca97f2978e0a15a9747939ffe666e89e Binary files /dev/null and b/DN_RGB/code/model/__pycache__/raftnetsnores.cpython-37.pyc differ diff --git a/DN_RGB/code/model/__pycache__/raftnetsres.cpython-37.pyc b/DN_RGB/code/model/__pycache__/raftnetsres.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..210ff239cf8a8ef5b2f93bff354c71f2bafaf6c1 Binary files /dev/null and b/DN_RGB/code/model/__pycache__/raftnetsres.cpython-37.pyc differ diff --git a/DN_RGB/code/model/__pycache__/raftnetstanh.cpython-37.pyc b/DN_RGB/code/model/__pycache__/raftnetstanh.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7644530f151b3be32a3ef694ea1190e8d1ba3869 Binary files /dev/null and b/DN_RGB/code/model/__pycache__/raftnetstanh.cpython-37.pyc differ diff --git a/DN_RGB/code/model/__pycache__/resnet.cpython-37.pyc b/DN_RGB/code/model/__pycache__/resnet.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a0a33f36a68d1a5405965d880d8d37e8a66a9557 Binary files /dev/null and b/DN_RGB/code/model/__pycache__/resnet.cpython-37.pyc differ diff --git a/DN_RGB/code/model/attention.py b/DN_RGB/code/model/attention.py new file mode 100644 index 0000000000000000000000000000000000000000..2f6fd9eed740f04c816ec109f75ee54e5c4f8eeb --- /dev/null +++ b/DN_RGB/code/model/attention.py @@ -0,0 +1,94 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +from torchvision import transforms +from torchvision import utils as vutils +from model import common +from utils.tools import extract_image_patches,\ + reduce_mean, reduce_sum, same_padding + +class PyramidAttention(nn.Module): + def __init__(self, level=5, res_scale=1, channel=64, reduction=2, ksize=3, stride=1, softmax_scale=10, average=True, conv=common.default_conv): + super(PyramidAttention, self).__init__() + self.ksize = ksize + self.stride = stride + self.res_scale = res_scale + self.softmax_scale = softmax_scale + self.scale = [1-i/10 for i in range(level)] + self.average = average + escape_NaN = torch.FloatTensor([1e-4]) + self.register_buffer('escape_NaN', escape_NaN) + self.conv_match_L_base = common.BasicBlock(conv,channel,channel//reduction, 1, bn=False, act=nn.PReLU()) + self.conv_match = common.BasicBlock(conv,channel, channel//reduction, 1, bn=False, act=nn.PReLU()) + self.conv_assembly = common.BasicBlock(conv,channel, channel,1,bn=False, act=nn.PReLU()) + + def forward(self, input): + res = input + #theta + match_base = self.conv_match_L_base(input) + shape_base = list(res.size()) + input_groups = torch.split(match_base,1,dim=0) + # patch size for matching + kernel = self.ksize + # raw_w is for reconstruction + raw_w = [] + # w is for matching + w = [] + #build feature pyramid + for i in range(len(self.scale)): + ref = input + if self.scale[i]!=1: + ref = F.interpolate(input, scale_factor=self.scale[i], mode='bicubic') + #feature transformation function f + base = self.conv_assembly(ref) + shape_input = base.shape + #sampling + raw_w_i = extract_image_patches(base, ksizes=[kernel, kernel], + strides=[self.stride,self.stride], + rates=[1, 1], + padding='same') # [N, C*k*k, L] + raw_w_i = raw_w_i.view(shape_input[0], shape_input[1], kernel, kernel, -1) + raw_w_i = raw_w_i.permute(0, 4, 1, 2, 3) # raw_shape: [N, L, C, k, k] + raw_w_i_groups = torch.split(raw_w_i, 1, dim=0) + raw_w.append(raw_w_i_groups) + + #feature transformation function g + ref_i = self.conv_match(ref) + shape_ref = ref_i.shape + #sampling + w_i = extract_image_patches(ref_i, ksizes=[self.ksize, self.ksize], + strides=[self.stride, self.stride], + rates=[1, 1], + padding='same') + w_i = w_i.view(shape_ref[0], shape_ref[1], self.ksize, self.ksize, -1) + w_i = w_i.permute(0, 4, 1, 2, 3) # w shape: [N, L, C, k, k] + w_i_groups = torch.split(w_i, 1, dim=0) + w.append(w_i_groups) + + y = [] + for idx, xi in enumerate(input_groups): + #group in a filter + wi = torch.cat([w[i][idx][0] for i in range(len(self.scale))],dim=0) # [L, C, k, k] + #normalize + max_wi = torch.max(torch.sqrt(reduce_sum(torch.pow(wi, 2), + axis=[1, 2, 3], + keepdim=True)), + self.escape_NaN) + wi_normed = wi/ max_wi + #matching + xi = same_padding(xi, [self.ksize, self.ksize], [1, 1], [1, 1]) # xi: 1*c*H*W + yi = F.conv2d(xi, wi_normed, stride=1) # [1, L, H, W] L = shape_ref[2]*shape_ref[3] + yi = yi.view(1,wi.shape[0], shape_base[2], shape_base[3]) # (B=1, C=32*32, H=32, W=32) + # softmax matching score + yi = F.softmax(yi*self.softmax_scale, dim=1) + + if self.average == False: + yi = (yi == yi.max(dim=1,keepdim=True)[0]).float() + + # deconv for patch pasting + raw_wi = torch.cat([raw_w[i][idx][0] for i in range(len(self.scale))],dim=0) + yi = F.conv_transpose2d(yi, raw_wi, stride=self.stride,padding=1)/4. + y.append(yi) + + y = torch.cat(y, dim=0)+res*self.res_scale # back to the mini-batch + return y \ No newline at end of file diff --git a/DN_RGB/code/model/common.py b/DN_RGB/code/model/common.py new file mode 100644 index 0000000000000000000000000000000000000000..d55d63132c23604c423b9c51e3f8cb3348bb40f6 --- /dev/null +++ b/DN_RGB/code/model/common.py @@ -0,0 +1,93 @@ +import math + +import torch +import torch.nn as nn +import torch.nn.functional as F + +def default_conv(in_channels, out_channels, kernel_size,stride=1, bias=True): + return nn.Conv2d( + in_channels, out_channels, kernel_size, + padding=(kernel_size//2),stride=stride, bias=bias) + +def spectral_conv(in_channels, out_channels, kernel_size,stride=1, bias=True): + return nn.utils.spectral_norm(nn.Conv2d( + in_channels, out_channels, kernel_size, + padding=(kernel_size//2),stride=stride, bias=bias)) + +class MeanShift(nn.Conv2d): + def __init__( + self, rgb_range, + rgb_mean=(0.4488, 0.4371, 0.4040), rgb_std=(1.0, 1.0, 1.0), sign=-1): + + super(MeanShift, self).__init__(3, 3, kernel_size=1) + std = torch.Tensor(rgb_std) + self.weight.data = torch.eye(3).view(3, 3, 1, 1) / std.view(3, 1, 1, 1) + self.bias.data = sign * rgb_range * torch.Tensor(rgb_mean) / std + for p in self.parameters(): + p.requires_grad = False + +class BasicBlock(nn.Sequential): + def __init__( + self, conv, in_channels, out_channels, kernel_size, stride=1, bias=True, + bn=False, act=nn.PReLU()): + + m = [conv(in_channels, out_channels, kernel_size, bias=bias)] + if bn: + m.append(nn.BatchNorm2d(out_channels)) + if act is not None: + m.append(act) + + super(BasicBlock, self).__init__(*m) + +class ResBlock(nn.Module): + def __init__( + self, conv, n_feats, kernel_size, + bias=True, bn=False, act=nn.PReLU(), res_scale=1): + + super(ResBlock, self).__init__() + m = [] + for i in range(2): + m.append(conv(n_feats, n_feats, kernel_size, bias=bias)) + if bn: + m.append(nn.BatchNorm2d(n_feats)) + if i == 0: + m.append(act) + + self.body = nn.Sequential(*m) + self.res_scale = res_scale + + def forward(self, x): + res = self.body(x).mul(self.res_scale) + res += x + + return res + +class Upsampler(nn.Sequential): + def __init__(self, conv, scale, n_feats, bn=False, act=False, bias=True): + + m = [] + if (scale & (scale - 1)) == 0: # Is scale = 2^n? + for _ in range(int(math.log(scale, 2))): + m.append(conv(n_feats, 4 * n_feats, 3, bias)) + m.append(nn.PixelShuffle(2)) + if bn: + m.append(nn.BatchNorm2d(n_feats)) + if act == 'relu': + m.append(nn.ReLU(True)) + elif act == 'prelu': + m.append(nn.PReLU(n_feats)) + + elif scale == 3: + m.append(conv(n_feats, 9 * n_feats, 3, bias)) + m.append(nn.PixelShuffle(3)) + if bn: + m.append(nn.BatchNorm2d(n_feats)) + if act == 'relu': + m.append(nn.ReLU(True)) + elif act == 'prelu': + m.append(nn.PReLU(n_feats)) + else: + raise NotImplementedError + + super(Upsampler, self).__init__(*m) + diff --git a/DN_RGB/code/model/ddbpn.py b/DN_RGB/code/model/ddbpn.py new file mode 100644 index 0000000000000000000000000000000000000000..f2185fcbde79334e77128463804313e325902536 --- /dev/null +++ b/DN_RGB/code/model/ddbpn.py @@ -0,0 +1,131 @@ +# Deep Back-Projection Networks For Super-Resolution +# https://arxiv.org/abs/1803.02735 + +from model import common + +import torch +import torch.nn as nn + + +def make_model(args, parent=False): + return DDBPN(args) + +def projection_conv(in_channels, out_channels, scale, up=True): + kernel_size, stride, padding = { + 2: (6, 2, 2), + 4: (8, 4, 2), + 8: (12, 8, 2) + }[scale] + if up: + conv_f = nn.ConvTranspose2d + else: + conv_f = nn.Conv2d + + return conv_f( + in_channels, out_channels, kernel_size, + stride=stride, padding=padding + ) + +class DenseProjection(nn.Module): + def __init__(self, in_channels, nr, scale, up=True, bottleneck=True): + super(DenseProjection, self).__init__() + if bottleneck: + self.bottleneck = nn.Sequential(*[ + nn.Conv2d(in_channels, nr, 1), + nn.PReLU(nr) + ]) + inter_channels = nr + else: + self.bottleneck = None + inter_channels = in_channels + + self.conv_1 = nn.Sequential(*[ + projection_conv(inter_channels, nr, scale, up), + nn.PReLU(nr) + ]) + self.conv_2 = nn.Sequential(*[ + projection_conv(nr, inter_channels, scale, not up), + nn.PReLU(inter_channels) + ]) + self.conv_3 = nn.Sequential(*[ + projection_conv(inter_channels, nr, scale, up), + nn.PReLU(nr) + ]) + + def forward(self, x): + if self.bottleneck is not None: + x = self.bottleneck(x) + + a_0 = self.conv_1(x) + b_0 = self.conv_2(a_0) + e = b_0.sub(x) + a_1 = self.conv_3(e) + + out = a_0.add(a_1) + + return out + +class DDBPN(nn.Module): + def __init__(self, args): + super(DDBPN, self).__init__() + scale = args.scale[0] + + n0 = 128 + nr = 32 + self.depth = 6 + + rgb_mean = (0.4488, 0.4371, 0.4040) + rgb_std = (1.0, 1.0, 1.0) + self.sub_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std) + initial = [ + nn.Conv2d(args.n_colors, n0, 3, padding=1), + nn.PReLU(n0), + nn.Conv2d(n0, nr, 1), + nn.PReLU(nr) + ] + self.initial = nn.Sequential(*initial) + + self.upmodules = nn.ModuleList() + self.downmodules = nn.ModuleList() + channels = nr + for i in range(self.depth): + self.upmodules.append( + DenseProjection(channels, nr, scale, True, i > 1) + ) + if i != 0: + channels += nr + + channels = nr + for i in range(self.depth - 1): + self.downmodules.append( + DenseProjection(channels, nr, scale, False, i != 0) + ) + channels += nr + + reconstruction = [ + nn.Conv2d(self.depth * nr, args.n_colors, 3, padding=1) + ] + self.reconstruction = nn.Sequential(*reconstruction) + + self.add_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std, 1) + + def forward(self, x): + x = self.sub_mean(x) + x = self.initial(x) + + h_list = [] + l_list = [] + for i in range(self.depth - 1): + if i == 0: + l = x + else: + l = torch.cat(l_list, dim=1) + h_list.append(self.upmodules[i](l)) + l_list.append(self.downmodules[i](torch.cat(h_list, dim=1))) + + h_list.append(self.upmodules[-1](torch.cat(l_list, dim=1))) + out = self.reconstruction(torch.cat(h_list, dim=1)) + out = self.add_mean(out) + + return out + diff --git a/DN_RGB/code/model/grunet.py b/DN_RGB/code/model/grunet.py new file mode 100644 index 0000000000000000000000000000000000000000..1c4cae8e0adb45c296d0c4dfeb8b42990e235064 --- /dev/null +++ b/DN_RGB/code/model/grunet.py @@ -0,0 +1,148 @@ +from model import common +from model import attention +import torch +from lambda_networks import LambdaLayer +import torch.nn as nn +import torch.cuda.amp as amp + +class ConvGRU(nn.Module): + def __init__(self, hidden_dim=128, input_dim=192+128): + super(ConvGRU, self).__init__() + self.convz = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + self.convr = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + self.convq = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + + def forward(self, h, x): + hx = torch.cat([h, x], dim=1) + + z = torch.sigmoid(self.convz(hx)) + r = torch.sigmoid(self.convr(hx)) + q = torch.tanh(self.convq(torch.cat([r*h, x], dim=1))) + + # h = (1-z) * h + z * q + # return h + return (1-z) * h + z * q + +class SepConvGRU(nn.Module): + def __init__(self, hidden_dim=128, input_dim=192+128): + super(SepConvGRU, self).__init__() + self.convz1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + self.convr1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + self.convq1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + + self.convz2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + self.convr2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + self.convq2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + + + def forward(self, h, x): + # horizontal + hx = torch.cat([h, x], dim=1) + z = torch.sigmoid(self.convz1(hx)) + r = torch.sigmoid(self.convr1(hx)) + q = torch.tanh(self.convq1(torch.cat([r*h, x], dim=1))) + h = (1-z) * h + z * q + + # vertical + hx = torch.cat([h, x], dim=1) + z = torch.sigmoid(self.convz2(hx)) + r = torch.sigmoid(self.convr2(hx)) + q = torch.tanh(self.convq2(torch.cat([r*h, x], dim=1))) + h = (1-z) * h + z * q + + return h + + +def make_model(args, parent=False): + return RAFTNET(args) + +class RAFTNET(nn.Module): + def __init__(self, args, conv=common.default_conv): + super(RAFTNET, self).__init__() + + n_resblocks = args.n_resblocks + n_feats = args.n_feats + kernel_size = 3 + scale = args.scale[0] + + rgb_mean = (0.4488, 0.4371, 0.4040) + rgb_std = (1.0, 1.0, 1.0) + self.sub_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std) + # msa = attention.PyramidAttention() + # define head module + m_head = [conv(args.n_colors, n_feats, kernel_size)] + # perhaps a shallow network here? + for i in range(n_resblocks//2): + m_head.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + # convert feature to image, shared + m_tail=[] + for i in range(n_resblocks//2): + m_tail.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + m_tail.append(conv(n_feats, args.n_colors, kernel_size)) + # middle recurrent part + layer = LambdaLayer( + dim = n_feats, + dim_out = n_feats, + r = args.lamradius, # the receptive field for relative positional encoding (23 x 23) + dim_k = 16, + heads = 4, + dim_u = 4, + normalization=args.normalization + ) + # define body module + m_body = [ + common.ResBlock( + conv, n_feats, kernel_size, nn.PReLU(), res_scale=args.res_scale + ) for _ in range(2) + ] + m_body.append(layer) + for i in range(2): + m_body.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + + m_body.append(conv(n_feats, n_feats, kernel_size)) + + self.add_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std, 1) + self.head = nn.Sequential(*m_head) + self.body = nn.Sequential(*m_body) + self.tail = nn.Sequential(*m_tail) + self.gru = ConvGRU(hidden_dim=n_feats,input_dim=n_feats) + self.recurrence = args.recurrence + self.detach = args.detach + # self.step_detach = args.step_detach + self.amp = args.amp + + def forward(self, x): + with amp.autocast(self.amp): + x=(x-0.5)/0.5 + x = self.head(x) + init = torch.zeros_like(x,device=x.device) + hidden = init + output_lst=[None]*self.recurrence + for i in range(self.recurrence): + gru_out=self.gru(hidden,x) + res=self.body(gru_out) + gru_out=res+gru_out + hidden=gru_out + output=self.tail(gru_out) + output_lst[i]=output*0.5+0.5 + return output_lst + + def load_state_dict(self, state_dict, strict=True): + own_state = self.state_dict() + for name, param in state_dict.items(): + if name in own_state: + if isinstance(param, nn.Parameter): + param = param.data + try: + own_state[name].copy_(param) + except Exception: + if name.find('tail') == -1: + raise RuntimeError('While copying the parameter named {}, ' + 'whose dimensions in the model are {} and ' + 'whose dimensions in the checkpoint are {}.' + .format(name, own_state[name].size(), param.size())) + elif strict: + if name.find('tail') == -1: + raise KeyError('unexpected key "{}" in state_dict' + .format(name)) + diff --git a/DN_RGB/code/model/lambdanet.py b/DN_RGB/code/model/lambdanet.py new file mode 100644 index 0000000000000000000000000000000000000000..cb4b95d766328d0ec6e070843b14c3658c4c641a --- /dev/null +++ b/DN_RGB/code/model/lambdanet.py @@ -0,0 +1,114 @@ +from model import common +import torch.nn as nn +from lambda_networks import LambdaLayer +import torch.cuda.amp as amp + +def make_model(args, parent=False): + return LAMBDANET(args) + +class MCheck(nn.Module): + def __init__(self): + super(MCheck, self).__init__() + self.kill = False + self.shape = None + + def forward(self, x): + if self.kill: + raise NotImplementedError("Shape checked here", self.shape, x.shape) + self.kill = True + self.shape = x.shape + return x + +class LAMBDANET(nn.Module): + def __init__(self, args, conv=common.default_conv): + super(LAMBDANET, self).__init__() + + n_resblocks = args.n_resblocks + n_feats = args.n_feats + kernel_size = 3 + scale = args.scale[0] + + rgb_mean = (0.4488, 0.4371, 0.4040) + rgb_std = (1.0, 1.0, 1.0) + self.sub_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std) + layer = LambdaLayer( + dim = n_feats, + dim_out = n_feats, + r = 23, # the receptive field for relative positional encoding (23 x 23) + dim_k = 16, + heads = 4, + dim_u = 4 + ) + # msa = attention.PyramidAttention() + # define head module + m_head = [conv(args.n_colors, n_feats, kernel_size)] + + # define body module + m_body = [ + common.ResBlock( + conv, n_feats, kernel_size, nn.PReLU(), res_scale=args.res_scale + ) for _ in range(n_resblocks//2) + ] + # m_body.append(msa) + m_body.append(layer) + for i in range(n_resblocks//2): + m_body.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + + m_body.append(conv(n_feats, n_feats, kernel_size)) + + # define tail module + #m_tail = [ + # common.Upsampler(conv, scale, n_feats, act=False), + # conv(n_feats, args.n_colors, kernel_size) + #] + m_tail = [ + conv(n_feats, args.n_colors, kernel_size) + ] + + self.add_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std, 1) + + self.head = nn.Sequential(*m_head) + self.body = nn.Sequential(*m_body) + self.tail = nn.Sequential(*m_tail) + + self.recurrence = args.recurrence + self.detach = args.detach + # self.step_detach = args.step_detach + self.amp = args.amp + + def forward(self, x): + #x = self.sub_mean(x) + with amp.autocast(self.amp): + last_output=x + output_lst=[None]*self.recurrence + for i in range(self.recurrence): + if self.detach: + last_output=last_output.detach() + out = self.head(last_output) + res = self.body(out) + res += out + output = self.tail(res) + last_output + output_lst[i]=output + last_output=output + #x = self.add_mean(x) + return output_lst + + def load_state_dict(self, state_dict, strict=True): + own_state = self.state_dict() + for name, param in state_dict.items(): + if name in own_state: + if isinstance(param, nn.Parameter): + param = param.data + try: + own_state[name].copy_(param) + except Exception: + if name.find('tail') == -1: + raise RuntimeError('While copying the parameter named {}, ' + 'whose dimensions in the model are {} and ' + 'whose dimensions in the checkpoint are {}.' + .format(name, own_state[name].size(), param.size())) + elif strict: + if name.find('tail') == -1: + raise KeyError('unexpected key "{}" in state_dict' + .format(name)) + diff --git a/DN_RGB/code/model/mdsr.py b/DN_RGB/code/model/mdsr.py new file mode 100644 index 0000000000000000000000000000000000000000..c55931bbd1172be4bf921eefd94cf3d7bea7e41a --- /dev/null +++ b/DN_RGB/code/model/mdsr.py @@ -0,0 +1,68 @@ +from model import common + +import torch.nn as nn + +def make_model(args, parent=False): + return MDSR(args) + +class MDSR(nn.Module): + def __init__(self, args, conv=common.default_conv): + super(MDSR, self).__init__() + n_resblocks = args.n_resblocks + n_feats = args.n_feats + kernel_size = 3 + self.scale_idx = 0 + + act = nn.ReLU(True) + + rgb_mean = (0.4488, 0.4371, 0.4040) + rgb_std = (1.0, 1.0, 1.0) + self.sub_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std) + + m_head = [conv(args.n_colors, n_feats, kernel_size)] + + self.pre_process = nn.ModuleList([ + nn.Sequential( + common.ResBlock(conv, n_feats, 5, act=act), + common.ResBlock(conv, n_feats, 5, act=act) + ) for _ in args.scale + ]) + + m_body = [ + common.ResBlock( + conv, n_feats, kernel_size, act=act + ) for _ in range(n_resblocks) + ] + m_body.append(conv(n_feats, n_feats, kernel_size)) + + self.upsample = nn.ModuleList([ + common.Upsampler( + conv, s, n_feats, act=False + ) for s in args.scale + ]) + + m_tail = [conv(n_feats, args.n_colors, kernel_size)] + + self.add_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std, 1) + + self.head = nn.Sequential(*m_head) + self.body = nn.Sequential(*m_body) + self.tail = nn.Sequential(*m_tail) + + def forward(self, x): + x = self.sub_mean(x) + x = self.head(x) + x = self.pre_process[self.scale_idx](x) + + res = self.body(x) + res += x + + x = self.upsample[self.scale_idx](res) + x = self.tail(x) + x = self.add_mean(x) + + return x + + def set_scale(self, scale_idx): + self.scale_idx = scale_idx + diff --git a/DN_RGB/code/model/panet.py b/DN_RGB/code/model/panet.py new file mode 100644 index 0000000000000000000000000000000000000000..8db1cc4637c8c3bd031f989af643f6c015e0fcfd --- /dev/null +++ b/DN_RGB/code/model/panet.py @@ -0,0 +1,82 @@ +from model import common +from model import attention +import torch.nn as nn + +def make_model(args, parent=False): + return PANET(args) + +class PANET(nn.Module): + def __init__(self, args, conv=common.default_conv): + super(PANET, self).__init__() + + n_resblocks = args.n_resblocks + n_feats = args.n_feats + kernel_size = 3 + scale = args.scale[0] + + rgb_mean = (0.4488, 0.4371, 0.4040) + rgb_std = (1.0, 1.0, 1.0) + self.sub_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std) + msa = attention.PyramidAttention() + # define head module + m_head = [conv(args.n_colors, n_feats, kernel_size)] + + # define body module + m_body = [ + common.ResBlock( + conv, n_feats, kernel_size, nn.PReLU(), res_scale=args.res_scale + ) for _ in range(n_resblocks//2) + ] + m_body.append(msa) + for i in range(n_resblocks//2): + m_body.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + + m_body.append(conv(n_feats, n_feats, kernel_size)) + + # define tail module + #m_tail = [ + # common.Upsampler(conv, scale, n_feats, act=False), + # conv(n_feats, args.n_colors, kernel_size) + #] + m_tail = [ + conv(n_feats, args.n_colors, kernel_size) + ] + + self.add_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std, 1) + + self.head = nn.Sequential(*m_head) + self.body = nn.Sequential(*m_body) + self.tail = nn.Sequential(*m_tail) + + def forward(self, x): + #x = self.sub_mean(x) + x = self.head(x) + + res = self.body(x) + + res += x + + x = self.tail(res) + #x = self.add_mean(x) + + return x + + def load_state_dict(self, state_dict, strict=True): + own_state = self.state_dict() + for name, param in state_dict.items(): + if name in own_state: + if isinstance(param, nn.Parameter): + param = param.data + try: + own_state[name].copy_(param) + except Exception: + if name.find('tail') == -1: + raise RuntimeError('While copying the parameter named {}, ' + 'whose dimensions in the model are {} and ' + 'whose dimensions in the checkpoint are {}.' + .format(name, own_state[name].size(), param.size())) + elif strict: + if name.find('tail') == -1: + raise KeyError('unexpected key "{}" in state_dict' + .format(name)) + diff --git a/DN_RGB/code/model/raftnet.py b/DN_RGB/code/model/raftnet.py new file mode 100644 index 0000000000000000000000000000000000000000..196b760adca47ee167193f0f876e55c9612a45cc --- /dev/null +++ b/DN_RGB/code/model/raftnet.py @@ -0,0 +1,146 @@ +from model import common +from model import attention +import torch +from lambda_networks import LambdaLayer +import torch.nn as nn +import torch.cuda.amp as amp + +class ConvGRU(nn.Module): + def __init__(self, hidden_dim=128, input_dim=192+128): + super(ConvGRU, self).__init__() + self.convz = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + self.convr = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + self.convq = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + + def forward(self, h, x): + hx = torch.cat([h, x], dim=1) + + z = torch.sigmoid(self.convz(hx)) + r = torch.sigmoid(self.convr(hx)) + q = torch.tanh(self.convq(torch.cat([r*h, x], dim=1))) + + # h = (1-z) * h + z * q + # return h + return (1-z) * h + z * q + +class SepConvGRU(nn.Module): + def __init__(self, hidden_dim=128, input_dim=192+128): + super(SepConvGRU, self).__init__() + self.convz1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + self.convr1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + self.convq1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + + self.convz2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + self.convr2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + self.convq2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + + + def forward(self, h, x): + # horizontal + hx = torch.cat([h, x], dim=1) + z = torch.sigmoid(self.convz1(hx)) + r = torch.sigmoid(self.convr1(hx)) + q = torch.tanh(self.convq1(torch.cat([r*h, x], dim=1))) + h = (1-z) * h + z * q + + # vertical + hx = torch.cat([h, x], dim=1) + z = torch.sigmoid(self.convz2(hx)) + r = torch.sigmoid(self.convr2(hx)) + q = torch.tanh(self.convq2(torch.cat([r*h, x], dim=1))) + h = (1-z) * h + z * q + + return h + + +def make_model(args, parent=False): + return RAFTNET(args) + +class RAFTNET(nn.Module): + def __init__(self, args, conv=common.default_conv): + super(RAFTNET, self).__init__() + + n_resblocks = args.n_resblocks + n_feats = args.n_feats + kernel_size = 3 + scale = args.scale[0] + + rgb_mean = (0.4488, 0.4371, 0.4040) + rgb_std = (1.0, 1.0, 1.0) + self.sub_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std) + # msa = attention.PyramidAttention() + # define head module + m_head = [conv(args.n_colors, n_feats, kernel_size)] + # perhaps a shallow network here? + for i in range(5): + m_head.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + # convert feature to image, shared + m_tail=[] + for i in range(5): + m_tail.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + m_tail.append(conv(n_feats, args.n_colors, kernel_size)) + # middle recurrent part + layer = LambdaLayer( + dim = n_feats, + dim_out = n_feats, + r = 23, # the receptive field for relative positional encoding (23 x 23) + dim_k = 16, + heads = 4, + dim_u = 4 + ) + # define body module + m_body = [ + common.ResBlock( + conv, n_feats, kernel_size, nn.PReLU(), res_scale=args.res_scale + ) for _ in range(n_resblocks//2) + ] + m_body.append(layer) + for i in range(n_resblocks//2): + m_body.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + + m_body.append(conv(n_feats, n_feats, kernel_size)) + + self.add_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std, 1) + + self.head = nn.Sequential(*m_head) + self.body = nn.Sequential(*m_body) + self.tail = nn.Sequential(*m_tail) + self.gru = ConvGRU(hidden_dim=64,input_dim=64) + self.recurrence = args.recurrence + self.detach = args.detach + # self.step_detach = args.step_detach + self.amp = args.amp + + def forward(self, x): + with amp.autocast(self.amp): + x=(x-0.5)/0.5 + x = self.head(x) + hidden = x.clone() + output_lst=[None]*self.recurrence + for i in range(self.recurrence): + gru_out=self.gru(hidden,x) + res=self.body(gru_out) + gru_out=res+gru_out + hidden=gru_out + output_lst[i]=self.tail(gru_out)*0.5+0.5 + return output_lst + + def load_state_dict(self, state_dict, strict=True): + own_state = self.state_dict() + for name, param in state_dict.items(): + if name in own_state: + if isinstance(param, nn.Parameter): + param = param.data + try: + own_state[name].copy_(param) + except Exception: + if name.find('tail') == -1: + raise RuntimeError('While copying the parameter named {}, ' + 'whose dimensions in the model are {} and ' + 'whose dimensions in the checkpoint are {}.' + .format(name, own_state[name].size(), param.size())) + elif strict: + if name.find('tail') == -1: + raise KeyError('unexpected key "{}" in state_dict' + .format(name)) + diff --git a/DN_RGB/code/model/raftnets.py b/DN_RGB/code/model/raftnets.py new file mode 100644 index 0000000000000000000000000000000000000000..04581c184876d01040dfe49f1166ab7bf504c2c8 --- /dev/null +++ b/DN_RGB/code/model/raftnets.py @@ -0,0 +1,155 @@ +from model import common +from model import attention +import torch +from lambda_networks import LambdaLayer +import torch.nn as nn +import torch.cuda.amp as amp + +class ConvGRU(nn.Module): + def __init__(self, hidden_dim=128, input_dim=192+128): + super(ConvGRU, self).__init__() + self.convz = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + self.convr = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + self.convq = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + + def forward(self, h, x): + hx = torch.cat([h, x], dim=1) + + z = torch.sigmoid(self.convz(hx)) + r = torch.sigmoid(self.convr(hx)) + q = torch.tanh(self.convq(torch.cat([r*h, x], dim=1))) + + # h = (1-z) * h + z * q + # return h + return (1-z) * h + z * q + +class SepConvGRU(nn.Module): + def __init__(self, hidden_dim=128, input_dim=192+128): + super(SepConvGRU, self).__init__() + self.convz1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + self.convr1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + self.convq1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + + self.convz2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + self.convr2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + self.convq2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + + + def forward(self, h, x): + # horizontal + hx = torch.cat([h, x], dim=1) + z = torch.sigmoid(self.convz1(hx)) + r = torch.sigmoid(self.convr1(hx)) + q = torch.tanh(self.convq1(torch.cat([r*h, x], dim=1))) + h = (1-z) * h + z * q + + # vertical + hx = torch.cat([h, x], dim=1) + z = torch.sigmoid(self.convz2(hx)) + r = torch.sigmoid(self.convr2(hx)) + q = torch.tanh(self.convq2(torch.cat([r*h, x], dim=1))) + h = (1-z) * h + z * q + + return h + + +def make_model(args, parent=False): + return RAFTNET(args) + +class RAFTNET(nn.Module): + def __init__(self, args, conv=common.default_conv): + super(RAFTNET, self).__init__() + + n_resblocks = args.n_resblocks + n_feats = args.n_feats + kernel_size = 3 + scale = args.scale[0] + + rgb_mean = (0.4488, 0.4371, 0.4040) + rgb_std = (1.0, 1.0, 1.0) + self.sub_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std) + # msa = attention.PyramidAttention() + # define head module + m_head = [conv(args.n_colors, n_feats, kernel_size)] + # perhaps a shallow network here? + for i in range(2): + m_head.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + # convert feature to image, shared + m_tail=[] + for i in range(2): + m_tail.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + m_tail.append(conv(n_feats, args.n_colors, kernel_size)) + # middle recurrent part + layer = LambdaLayer( + dim = n_feats, + dim_out = n_feats, + r = args.lamradius, # the receptive field for relative positional encoding (23 x 23) + dim_k = 16, + heads = 4, + dim_u = 4, + normalization=args.normalization + ) + # define body module + m_body = [ + common.ResBlock( + conv, n_feats, kernel_size, nn.PReLU(), res_scale=args.res_scale + ) for _ in range(n_resblocks//2) + ] + m_body.append(layer) + for i in range(n_resblocks//2): + m_body.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + + m_body.append(conv(n_feats, n_feats, kernel_size)) + + self.add_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std, 1) + self.hidden_encoder=nn.Sequential( + common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale), + common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale), + common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale) + ) + self.head = nn.Sequential(*m_head) + self.body = nn.Sequential(*m_body) + self.tail = nn.Sequential(*m_tail) + self.gru = ConvGRU(hidden_dim=n_feats,input_dim=n_feats) + self.recurrence = args.recurrence + self.detach = args.detach + # self.step_detach = args.step_detach + self.amp = args.amp + + def forward(self, x): + with amp.autocast(self.amp): + x=(x-0.5)/0.5 + x = self.head(x) + if self.detach: + hidden = self.hidden_encoder(x.detach()) + else: + hidden=self.hidden_encoder(x) + output_lst=[None]*self.recurrence + for i in range(self.recurrence): + gru_out=self.gru(hidden,x) + res=self.body(gru_out) + gru_out=res+gru_out + hidden=gru_out + output=self.tail(gru_out) + output_lst[i]=output*0.5+0.5 + return output_lst + + def load_state_dict(self, state_dict, strict=True): + own_state = self.state_dict() + for name, param in state_dict.items(): + if name in own_state: + if isinstance(param, nn.Parameter): + param = param.data + try: + own_state[name].copy_(param) + except Exception: + if name.find('tail') == -1: + raise RuntimeError('While copying the parameter named {}, ' + 'whose dimensions in the model are {} and ' + 'whose dimensions in the checkpoint are {}.' + .format(name, own_state[name].size(), param.size())) + elif strict: + if name.find('tail') == -1: + raise KeyError('unexpected key "{}" in state_dict' + .format(name)) + diff --git a/DN_RGB/code/model/raftnetsingle.py b/DN_RGB/code/model/raftnetsingle.py new file mode 100644 index 0000000000000000000000000000000000000000..a8c8372e02b74f32c40a98d5b736328c5a26916e --- /dev/null +++ b/DN_RGB/code/model/raftnetsingle.py @@ -0,0 +1,150 @@ +from model import common +from model import attention +import torch +from lambda_networks import LambdaLayer +import torch.nn as nn +import torch.cuda.amp as amp + +class ConvGRU(nn.Module): + def __init__(self, hidden_dim=128, input_dim=192+128): + super(ConvGRU, self).__init__() + self.convz = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + self.convr = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + self.convq = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + + def forward(self, h, x): + hx = torch.cat([h, x], dim=1) + + z = torch.sigmoid(self.convz(hx)) + r = torch.sigmoid(self.convr(hx)) + q = torch.tanh(self.convq(torch.cat([r*h, x], dim=1))) + + # h = (1-z) * h + z * q + # return h + return (1-z) * h + z * q + +class SepConvGRU(nn.Module): + def __init__(self, hidden_dim=128, input_dim=192+128): + super(SepConvGRU, self).__init__() + self.convz1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + self.convr1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + self.convq1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + + self.convz2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + self.convr2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + self.convq2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + + + def forward(self, h, x): + # horizontal + hx = torch.cat([h, x], dim=1) + z = torch.sigmoid(self.convz1(hx)) + r = torch.sigmoid(self.convr1(hx)) + q = torch.tanh(self.convq1(torch.cat([r*h, x], dim=1))) + h = (1-z) * h + z * q + + # vertical + hx = torch.cat([h, x], dim=1) + z = torch.sigmoid(self.convz2(hx)) + r = torch.sigmoid(self.convr2(hx)) + q = torch.tanh(self.convq2(torch.cat([r*h, x], dim=1))) + h = (1-z) * h + z * q + + return h + + +def make_model(args, parent=False): + return RAFTNET(args) + +class RAFTNET(nn.Module): + def __init__(self, args, conv=common.default_conv): + super(RAFTNET, self).__init__() + + n_resblocks = args.n_resblocks + n_feats = args.n_feats + kernel_size = 3 + scale = args.scale[0] + + rgb_mean = (0.4488, 0.4371, 0.4040) + rgb_std = (1.0, 1.0, 1.0) + self.sub_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std) + # msa = attention.PyramidAttention() + # define head module + m_head = [conv(args.n_colors, n_feats, kernel_size)] + # perhaps a shallow network here? + for i in range(2): + m_head.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + # convert feature to image, shared + m_tail=[] + for i in range(2): + m_tail.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + m_tail.append(conv(n_feats, args.n_colors, kernel_size)) + # middle recurrent part + layer = LambdaLayer( + dim = n_feats, + dim_out = n_feats, + r = 23, # the receptive field for relative positional encoding (23 x 23) + dim_k = 16, + heads = 4, + dim_u = 4, + normalization=args.normalization + ) + # define body module + m_body = [ + common.ResBlock( + conv, n_feats, kernel_size, nn.PReLU(), res_scale=args.res_scale + ) for _ in range(n_resblocks//2) + ] + m_body.append(layer) + for i in range(n_resblocks//2): + m_body.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + + m_body.append(conv(n_feats, n_feats, kernel_size)) + + self.add_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std, 1) + self.hidden_encoder=nn.Sequential( + common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale), + common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale), + common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale) + ) + self.head = nn.Sequential(*m_head) + self.body = nn.Sequential(*m_body) + self.tail = nn.Sequential(*m_tail) + # self.gru = ConvGRU(hidden_dim=64,input_dim=64) + self.recurrence = args.recurrence + self.detach = args.detach + # self.step_detach = args.step_detach + self.amp = args.amp + + def forward(self, x): + with amp.autocast(self.amp): + x=(x-0.5)/0.5 + x = self.head(x) + hidden = self.hidden_encoder(x) + output_lst=[None]*self.recurrence + for i in range(1): + res=self.body(hidden) + gru_out=res+hidden + output=self.tail(gru_out) + output_lst[i]=output*0.5+0.5 + return output_lst + + def load_state_dict(self, state_dict, strict=True): + own_state = self.state_dict() + for name, param in state_dict.items(): + if name in own_state: + if isinstance(param, nn.Parameter): + param = param.data + try: + own_state[name].copy_(param) + except Exception: + if name.find('tail') == -1: + raise RuntimeError('While copying the parameter named {}, ' + 'whose dimensions in the model are {} and ' + 'whose dimensions in the checkpoint are {}.' + .format(name, own_state[name].size(), param.size())) + elif strict: + if name.find('tail') == -1: + raise KeyError('unexpected key "{}" in state_dict' + .format(name)) + diff --git a/DN_RGB/code/model/raftnetsnores.py b/DN_RGB/code/model/raftnetsnores.py new file mode 100644 index 0000000000000000000000000000000000000000..1ab56793adb2328b858d24d4c42d123366ec662e --- /dev/null +++ b/DN_RGB/code/model/raftnetsnores.py @@ -0,0 +1,155 @@ +from model import common +from model import attention +import torch +from lambda_networks import LambdaLayer +import torch.nn as nn +import torch.cuda.amp as amp + +class ConvGRU(nn.Module): + def __init__(self, hidden_dim=128, input_dim=192+128): + super(ConvGRU, self).__init__() + self.convz = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + self.convr = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + self.convq = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + + def forward(self, h, x): + hx = torch.cat([h, x], dim=1) + + z = torch.sigmoid(self.convz(hx)) + r = torch.sigmoid(self.convr(hx)) + q = torch.tanh(self.convq(torch.cat([r*h, x], dim=1))) + + # h = (1-z) * h + z * q + # return h + return (1-z) * h + z * q + +class SepConvGRU(nn.Module): + def __init__(self, hidden_dim=128, input_dim=192+128): + super(SepConvGRU, self).__init__() + self.convz1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + self.convr1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + self.convq1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + + self.convz2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + self.convr2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + self.convq2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + + + def forward(self, h, x): + # horizontal + hx = torch.cat([h, x], dim=1) + z = torch.sigmoid(self.convz1(hx)) + r = torch.sigmoid(self.convr1(hx)) + q = torch.tanh(self.convq1(torch.cat([r*h, x], dim=1))) + h = (1-z) * h + z * q + + # vertical + hx = torch.cat([h, x], dim=1) + z = torch.sigmoid(self.convz2(hx)) + r = torch.sigmoid(self.convr2(hx)) + q = torch.tanh(self.convq2(torch.cat([r*h, x], dim=1))) + h = (1-z) * h + z * q + + return h + + +def make_model(args, parent=False): + return RAFTNET(args) + +class RAFTNET(nn.Module): + def __init__(self, args, conv=common.default_conv): + super(RAFTNET, self).__init__() + + n_resblocks = args.n_resblocks + n_feats = args.n_feats + kernel_size = 3 + scale = args.scale[0] + + rgb_mean = (0.4488, 0.4371, 0.4040) + rgb_std = (1.0, 1.0, 1.0) + self.sub_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std) + # msa = attention.PyramidAttention() + # define head module + m_head = [conv(args.n_colors, n_feats, kernel_size)] + # perhaps a shallow network here? + for i in range(2): + m_head.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + # convert feature to image, shared + m_tail=[] + for i in range(2): + m_tail.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + m_tail.append(conv(n_feats, args.n_colors, kernel_size)) + # middle recurrent part + layer = LambdaLayer( + dim = n_feats, + dim_out = n_feats, + r = 23, # the receptive field for relative positional encoding (23 x 23) + dim_k = 16, + heads = 4, + dim_u = 4, + normalization=args.normalization + ) + # define body module + m_body = [ + common.ResBlock( + conv, n_feats, kernel_size, nn.PReLU(), res_scale=args.res_scale + ) for _ in range(n_resblocks//2) + ] + m_body.append(layer) + for i in range(n_resblocks//2): + m_body.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + + m_body.append(conv(n_feats, n_feats, kernel_size)) + + self.add_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std, 1) + self.hidden_encoder=nn.Sequential( + common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale), + common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale), + common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale) + ) + self.head = nn.Sequential(*m_head) + self.body = nn.Sequential(*m_body) + self.tail = nn.Sequential(*m_tail) + self.gru = ConvGRU(hidden_dim=n_feats,input_dim=n_feats) + self.recurrence = args.recurrence + self.detach = args.detach + # self.step_detach = args.step_detach + self.amp = args.amp + + def forward(self, x): + with amp.autocast(self.amp): + x=(x-0.5)/0.5 + x = self.head(x) + if self.detach: + hidden = self.hidden_encoder(x.detach()) + else: + hidden=self.hidden_encoder(x) + output_lst=[None]*self.recurrence + for i in range(self.recurrence): + gru_out=self.gru(hidden,x) + res=self.body(gru_out) + gru_out=res + hidden=gru_out + output=self.tail(gru_out) + output_lst[i]=output*0.5+0.5 + return output_lst + + def load_state_dict(self, state_dict, strict=True): + own_state = self.state_dict() + for name, param in state_dict.items(): + if name in own_state: + if isinstance(param, nn.Parameter): + param = param.data + try: + own_state[name].copy_(param) + except Exception: + if name.find('tail') == -1: + raise RuntimeError('While copying the parameter named {}, ' + 'whose dimensions in the model are {} and ' + 'whose dimensions in the checkpoint are {}.' + .format(name, own_state[name].size(), param.size())) + elif strict: + if name.find('tail') == -1: + raise KeyError('unexpected key "{}" in state_dict' + .format(name)) + diff --git a/DN_RGB/code/model/raftnetsres.py b/DN_RGB/code/model/raftnetsres.py new file mode 100644 index 0000000000000000000000000000000000000000..77e99450251f8bfa9ba5626ae1bb1f245dbfbe1f --- /dev/null +++ b/DN_RGB/code/model/raftnetsres.py @@ -0,0 +1,159 @@ +from model import common +from model import attention +import torch +from lambda_networks import LambdaLayer +import torch.nn as nn +import torch.cuda.amp as amp + +class ConvGRU(nn.Module): + def __init__(self, hidden_dim=128, input_dim=192+128): + super(ConvGRU, self).__init__() + self.convz = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + self.convr = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + self.convq = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + + def forward(self, h, x): + hx = torch.cat([h, x], dim=1) + + z = torch.sigmoid(self.convz(hx)) + r = torch.sigmoid(self.convr(hx)) + q = torch.tanh(self.convq(torch.cat([r*h, x], dim=1))) + + # h = (1-z) * h + z * q + # return h + return (1-z) * h + z * q + +class SepConvGRU(nn.Module): + def __init__(self, hidden_dim=128, input_dim=192+128): + super(SepConvGRU, self).__init__() + self.convz1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + self.convr1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + self.convq1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + + self.convz2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + self.convr2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + self.convq2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + + + def forward(self, h, x): + # horizontal + hx = torch.cat([h, x], dim=1) + z = torch.sigmoid(self.convz1(hx)) + r = torch.sigmoid(self.convr1(hx)) + q = torch.tanh(self.convq1(torch.cat([r*h, x], dim=1))) + h = (1-z) * h + z * q + + # vertical + hx = torch.cat([h, x], dim=1) + z = torch.sigmoid(self.convz2(hx)) + r = torch.sigmoid(self.convr2(hx)) + q = torch.tanh(self.convq2(torch.cat([r*h, x], dim=1))) + h = (1-z) * h + z * q + + return h + + +def make_model(args, parent=False): + return RAFTNET(args) + +class RAFTNET(nn.Module): + def __init__(self, args, conv=common.default_conv): + super(RAFTNET, self).__init__() + + n_resblocks = args.n_resblocks + n_feats = args.n_feats + kernel_size = 3 + scale = args.scale[0] + + rgb_mean = (0.4488, 0.4371, 0.4040) + rgb_std = (1.0, 1.0, 1.0) + self.sub_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std) + # msa = attention.PyramidAttention() + # define head module + m_head = [conv(args.n_colors, n_feats, kernel_size)] + # perhaps a shallow network here? + for i in range(2): + m_head.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + # convert feature to image, shared + m_tail=[] + for i in range(2): + m_tail.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + m_tail.append(conv(n_feats, args.n_colors, kernel_size)) + # middle recurrent part + self.layer = LambdaLayer( + dim = n_feats, + dim_out = n_feats, + r = args.lamradius, # the receptive field for relative positional encoding (23 x 23) + dim_k = 16, + heads = 4, + dim_u = 4, + normalization=args.normalization + ) + # define body module + m_body1 = [ + common.ResBlock( + conv, n_feats, kernel_size, nn.PReLU(), res_scale=args.res_scale + ) for _ in range(n_resblocks//2) + ] + # m_body.append(layer) + m_body2=[] + for i in range(n_resblocks//2): + m_body2.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + + # m_body2.append(conv(n_feats, n_feats, kernel_size)) + + self.add_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std, 1) + self.hidden_encoder=nn.Sequential( + common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale), + common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale), + common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale) + ) + self.head = nn.Sequential(*m_head) + self.body1 = nn.Sequential(*m_body1) + self.body2 = nn.Sequential(*m_body2) + self.tail = nn.Sequential(*m_tail) + self.gru = ConvGRU(hidden_dim=n_feats,input_dim=n_feats) + self.recurrence = args.recurrence + self.detach = args.detach + # self.step_detach = args.step_detach + self.amp = args.amp + + def forward(self, x): + with amp.autocast(self.amp): + x=(x-0.5)/0.5 + x = self.head(x) + if self.detach: + hidden = self.hidden_encoder(x.detach()) + else: + hidden=self.hidden_encoder(x) + output_lst=[None]*self.recurrence + for i in range(self.recurrence): + gru_out=self.gru(hidden,x) + tmp=self.body1(gru_out) + tmp_res=self.layer(tmp) + res=self.body2(tmp_res+tmp) + gru_out=res+gru_out + hidden=gru_out + output=self.tail(gru_out) + output_lst[i]=output*0.5+0.5 + return output_lst + + def load_state_dict(self, state_dict, strict=True): + own_state = self.state_dict() + for name, param in state_dict.items(): + if name in own_state: + if isinstance(param, nn.Parameter): + param = param.data + try: + own_state[name].copy_(param) + except Exception: + if name.find('tail') == -1: + raise RuntimeError('While copying the parameter named {}, ' + 'whose dimensions in the model are {} and ' + 'whose dimensions in the checkpoint are {}.' + .format(name, own_state[name].size(), param.size())) + elif strict: + if name.find('tail') == -1: + raise KeyError('unexpected key "{}" in state_dict' + .format(name)) + diff --git a/DN_RGB/code/model/raftnetstanh.py b/DN_RGB/code/model/raftnetstanh.py new file mode 100644 index 0000000000000000000000000000000000000000..00cb034b161d3fbd4e2f70f9d828feeed515826c --- /dev/null +++ b/DN_RGB/code/model/raftnetstanh.py @@ -0,0 +1,151 @@ +from model import common +from model import attention +import torch +from lambda_networks import LambdaLayer +import torch.nn as nn +import torch.cuda.amp as amp + +class ConvGRU(nn.Module): + def __init__(self, hidden_dim=128, input_dim=192+128): + super(ConvGRU, self).__init__() + self.convz = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + self.convr = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + self.convq = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + + def forward(self, h, x): + hx = torch.cat([h, x], dim=1) + + z = torch.sigmoid(self.convz(hx)) + r = torch.sigmoid(self.convr(hx)) + q = torch.tanh(self.convq(torch.cat([r*h, x], dim=1))) + + # h = (1-z) * h + z * q + # return h + return (1-z) * h + z * q + +class SepConvGRU(nn.Module): + def __init__(self, hidden_dim=128, input_dim=192+128): + super(SepConvGRU, self).__init__() + self.convz1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + self.convr1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + self.convq1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + + self.convz2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + self.convr2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + self.convq2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + + + def forward(self, h, x): + # horizontal + hx = torch.cat([h, x], dim=1) + z = torch.sigmoid(self.convz1(hx)) + r = torch.sigmoid(self.convr1(hx)) + q = torch.tanh(self.convq1(torch.cat([r*h, x], dim=1))) + h = (1-z) * h + z * q + + # vertical + hx = torch.cat([h, x], dim=1) + z = torch.sigmoid(self.convz2(hx)) + r = torch.sigmoid(self.convr2(hx)) + q = torch.tanh(self.convq2(torch.cat([r*h, x], dim=1))) + h = (1-z) * h + z * q + + return h + + +def make_model(args, parent=False): + return RAFTNET(args) + +class RAFTNET(nn.Module): + def __init__(self, args, conv=common.default_conv): + super(RAFTNET, self).__init__() + + n_resblocks = args.n_resblocks + n_feats = args.n_feats + kernel_size = 3 + scale = args.scale[0] + + rgb_mean = (0.4488, 0.4371, 0.4040) + rgb_std = (1.0, 1.0, 1.0) + self.sub_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std) + # msa = attention.PyramidAttention() + # define head module + m_head = [conv(args.n_colors, n_feats, kernel_size)] + # perhaps a shallow network here? + for i in range(2): + m_head.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + # convert feature to image, shared + m_tail=[] + for i in range(2): + m_tail.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + m_tail.append(conv(n_feats, args.n_colors, kernel_size)) + # middle recurrent part + layer = LambdaLayer( + dim = n_feats, + dim_out = n_feats, + r = 23, # the receptive field for relative positional encoding (23 x 23) + dim_k = 16, + heads = 4, + dim_u = 4 + ) + # define body module + m_body = [ + common.ResBlock( + conv, n_feats, kernel_size, nn.PReLU(), res_scale=args.res_scale + ) for _ in range(n_resblocks//2) + ] + m_body.append(layer) + for i in range(n_resblocks//2): + m_body.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + + m_body.append(conv(n_feats, n_feats, kernel_size)) + + self.add_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std, 1) + self.hidden_encoder=nn.Sequential( + common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale), + common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale), + common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale) + ) + self.head = nn.Sequential(*m_head) + self.body = nn.Sequential(*m_body) + self.tail = nn.Sequential(*m_tail) + self.gru = ConvGRU(hidden_dim=n_feats,input_dim=n_feats) + self.recurrence = args.recurrence + self.detach = args.detach + # self.step_detach = args.step_detach + self.amp = args.amp + + def forward(self, x): + with amp.autocast(self.amp): + x=(x-0.5)/0.5 + x = self.head(x) + hidden = self.hidden_encoder(x) + output_lst=[None]*self.recurrence + for i in range(self.recurrence): + gru_out=self.gru(hidden,x) + res=self.body(gru_out) + gru_out=res+gru_out + hidden=gru_out + output=self.tail(gru_out) + output_lst[i]=output.tanh()*0.5+0.5 + return output_lst + + def load_state_dict(self, state_dict, strict=True): + own_state = self.state_dict() + for name, param in state_dict.items(): + if name in own_state: + if isinstance(param, nn.Parameter): + param = param.data + try: + own_state[name].copy_(param) + except Exception: + if name.find('tail') == -1: + raise RuntimeError('While copying the parameter named {}, ' + 'whose dimensions in the model are {} and ' + 'whose dimensions in the checkpoint are {}.' + .format(name, own_state[name].size(), param.size())) + elif strict: + if name.find('tail') == -1: + raise KeyError('unexpected key "{}" in state_dict' + .format(name)) + diff --git a/DN_RGB/code/model/rcan.py b/DN_RGB/code/model/rcan.py new file mode 100644 index 0000000000000000000000000000000000000000..4f4e26b923f9b8378766b83f358a5b2c8720f520 --- /dev/null +++ b/DN_RGB/code/model/rcan.py @@ -0,0 +1,144 @@ +## ECCV-2018-Image Super-Resolution Using Very Deep Residual Channel Attention Networks +## https://arxiv.org/abs/1807.02758 +from model import common + +import torch.nn as nn + +def make_model(args, parent=False): + return RCAN(args) + +## Channel Attention (CA) Layer +class CALayer(nn.Module): + def __init__(self, channel, reduction=16): + super(CALayer, self).__init__() + # global average pooling: feature --> point + self.avg_pool = nn.AdaptiveAvgPool2d(1) + # feature channel downscale and upscale --> channel weight + self.conv_du = nn.Sequential( + nn.Conv2d(channel, channel // reduction, 1, padding=0, bias=True), + nn.ReLU(inplace=True), + nn.Conv2d(channel // reduction, channel, 1, padding=0, bias=True), + nn.Sigmoid() + ) + + def forward(self, x): + y = self.avg_pool(x) + y = self.conv_du(y) + return x * y + +## Residual Channel Attention Block (RCAB) +class RCAB(nn.Module): + def __init__( + self, conv, n_feat, kernel_size, reduction, + bias=True, bn=False, act=nn.ReLU(True), res_scale=1): + + super(RCAB, self).__init__() + modules_body = [] + for i in range(2): + modules_body.append(conv(n_feat, n_feat, kernel_size, bias=bias)) + if bn: modules_body.append(nn.BatchNorm2d(n_feat)) + if i == 0: modules_body.append(act) + modules_body.append(CALayer(n_feat, reduction)) + self.body = nn.Sequential(*modules_body) + self.res_scale = res_scale + + def forward(self, x): + res = self.body(x) + #res = self.body(x).mul(self.res_scale) + res += x + return res + +## Residual Group (RG) +class ResidualGroup(nn.Module): + def __init__(self, conv, n_feat, kernel_size, reduction, act, res_scale, n_resblocks): + super(ResidualGroup, self).__init__() + modules_body = [] + modules_body = [ + RCAB( + conv, n_feat, kernel_size, reduction, bias=True, bn=False, act=nn.ReLU(True), res_scale=1) \ + for _ in range(n_resblocks)] + modules_body.append(conv(n_feat, n_feat, kernel_size)) + self.body = nn.Sequential(*modules_body) + + def forward(self, x): + res = self.body(x) + res += x + return res + +## Residual Channel Attention Network (RCAN) +class RCAN(nn.Module): + def __init__(self, args, conv=common.default_conv): + super(RCAN, self).__init__() + + n_resgroups = args.n_resgroups + n_resblocks = args.n_resblocks + n_feats = args.n_feats + kernel_size = 3 + reduction = args.reduction + scale = args.scale[0] + act = nn.ReLU(True) + + # RGB mean for DIV2K + rgb_mean = (0.4488, 0.4371, 0.4040) + rgb_std = (1.0, 1.0, 1.0) + self.sub_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std) + + # define head module + modules_head = [conv(args.n_colors, n_feats, kernel_size)] + + # define body module + modules_body = [ + ResidualGroup( + conv, n_feats, kernel_size, reduction, act=act, res_scale=args.res_scale, n_resblocks=n_resblocks) \ + for _ in range(n_resgroups)] + + modules_body.append(conv(n_feats, n_feats, kernel_size)) + + # define tail module + modules_tail = [ + common.Upsampler(conv, scale, n_feats, act=False), + conv(n_feats, args.n_colors, kernel_size)] + + self.add_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std, 1) + + self.head = nn.Sequential(*modules_head) + self.body = nn.Sequential(*modules_body) + self.tail = nn.Sequential(*modules_tail) + + def forward(self, x): + x = self.sub_mean(x) + x = self.head(x) + + res = self.body(x) + res += x + + x = self.tail(res) + x = self.add_mean(x) + + return x + + def load_state_dict(self, state_dict, strict=False): + own_state = self.state_dict() + for name, param in state_dict.items(): + if name in own_state: + if isinstance(param, nn.Parameter): + param = param.data + try: + own_state[name].copy_(param) + except Exception: + if name.find('tail') >= 0: + print('Replace pre-trained upsampler to new one...') + else: + raise RuntimeError('While copying the parameter named {}, ' + 'whose dimensions in the model are {} and ' + 'whose dimensions in the checkpoint are {}.' + .format(name, own_state[name].size(), param.size())) + elif strict: + if name.find('tail') == -1: + raise KeyError('unexpected key "{}" in state_dict' + .format(name)) + + if strict: + missing = set(own_state.keys()) - set(state_dict.keys()) + if len(missing) > 0: + raise KeyError('missing keys in state_dict: "{}"'.format(missing)) diff --git a/DN_RGB/code/model/rdn.py b/DN_RGB/code/model/rdn.py new file mode 100644 index 0000000000000000000000000000000000000000..0b7001d85ad760e32fc735267d913a4c5f62cb15 --- /dev/null +++ b/DN_RGB/code/model/rdn.py @@ -0,0 +1,105 @@ +# Residual Dense Network for Image Super-Resolution +# https://arxiv.org/abs/1802.08797 + +from model import common + +import torch +import torch.nn as nn + + +def make_model(args, parent=False): + return RDN(args) + +class RDB_Conv(nn.Module): + def __init__(self, inChannels, growRate, kSize=3): + super(RDB_Conv, self).__init__() + Cin = inChannels + G = growRate + self.conv = nn.Sequential(*[ + nn.Conv2d(Cin, G, kSize, padding=(kSize-1)//2, stride=1), + nn.ReLU() + ]) + + def forward(self, x): + out = self.conv(x) + return torch.cat((x, out), 1) + +class RDB(nn.Module): + def __init__(self, growRate0, growRate, nConvLayers, kSize=3): + super(RDB, self).__init__() + G0 = growRate0 + G = growRate + C = nConvLayers + + convs = [] + for c in range(C): + convs.append(RDB_Conv(G0 + c*G, G)) + self.convs = nn.Sequential(*convs) + + # Local Feature Fusion + self.LFF = nn.Conv2d(G0 + C*G, G0, 1, padding=0, stride=1) + + def forward(self, x): + return self.LFF(self.convs(x)) + x + +class RDN(nn.Module): + def __init__(self, args): + super(RDN, self).__init__() + r = args.scale[0] + G0 = args.G0 + kSize = args.RDNkSize + + # number of RDB blocks, conv layers, out channels + self.D, C, G = { + 'A': (20, 6, 32), + 'B': (16, 8, 64), + }[args.RDNconfig] + + # Shallow feature extraction net + self.SFENet1 = nn.Conv2d(args.n_colors, G0, kSize, padding=(kSize-1)//2, stride=1) + self.SFENet2 = nn.Conv2d(G0, G0, kSize, padding=(kSize-1)//2, stride=1) + + # Redidual dense blocks and dense feature fusion + self.RDBs = nn.ModuleList() + for i in range(self.D): + self.RDBs.append( + RDB(growRate0 = G0, growRate = G, nConvLayers = C) + ) + + # Global Feature Fusion + self.GFF = nn.Sequential(*[ + nn.Conv2d(self.D * G0, G0, 1, padding=0, stride=1), + nn.Conv2d(G0, G0, kSize, padding=(kSize-1)//2, stride=1) + ]) + + # Up-sampling net + if r == 2 or r == 3: + self.UPNet = nn.Sequential(*[ + nn.Conv2d(G0, G * r * r, kSize, padding=(kSize-1)//2, stride=1), + nn.PixelShuffle(r), + nn.Conv2d(G, args.n_colors, kSize, padding=(kSize-1)//2, stride=1) + ]) + elif r == 4: + self.UPNet = nn.Sequential(*[ + nn.Conv2d(G0, G * 4, kSize, padding=(kSize-1)//2, stride=1), + nn.PixelShuffle(2), + nn.Conv2d(G, G * 4, kSize, padding=(kSize-1)//2, stride=1), + nn.PixelShuffle(2), + nn.Conv2d(G, args.n_colors, kSize, padding=(kSize-1)//2, stride=1) + ]) + else: + raise ValueError("scale must be 2 or 3 or 4.") + + def forward(self, x): + f__1 = self.SFENet1(x) + x = self.SFENet2(f__1) + + RDBs_out = [] + for i in range(self.D): + x = self.RDBs[i](x) + RDBs_out.append(x) + + x = self.GFF(torch.cat(RDBs_out,1)) + x += f__1 + + return self.UPNet(x) diff --git a/DN_RGB/code/model/resnet.py b/DN_RGB/code/model/resnet.py new file mode 100644 index 0000000000000000000000000000000000000000..cf11e01d599d6ce3df255074946154ebd5db523f --- /dev/null +++ b/DN_RGB/code/model/resnet.py @@ -0,0 +1,150 @@ +from model import common +from model import attention +import torch +from lambda_networks import LambdaLayer +import torch.nn as nn +import torch.cuda.amp as amp + +class ConvGRU(nn.Module): + def __init__(self, hidden_dim=128, input_dim=192+128): + super(ConvGRU, self).__init__() + self.convz = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + self.convr = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + self.convq = nn.Conv2d(hidden_dim+input_dim, hidden_dim, 3, padding=1) + + def forward(self, h, x): + hx = torch.cat([h, x], dim=1) + + z = torch.sigmoid(self.convz(hx)) + r = torch.sigmoid(self.convr(hx)) + q = torch.tanh(self.convq(torch.cat([r*h, x], dim=1))) + + # h = (1-z) * h + z * q + # return h + return (1-z) * h + z * q + +class SepConvGRU(nn.Module): + def __init__(self, hidden_dim=128, input_dim=192+128): + super(SepConvGRU, self).__init__() + self.convz1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + self.convr1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + self.convq1 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (1,5), padding=(0,2)) + + self.convz2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + self.convr2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + self.convq2 = nn.Conv2d(hidden_dim+input_dim, hidden_dim, (5,1), padding=(2,0)) + + + def forward(self, h, x): + # horizontal + hx = torch.cat([h, x], dim=1) + z = torch.sigmoid(self.convz1(hx)) + r = torch.sigmoid(self.convr1(hx)) + q = torch.tanh(self.convq1(torch.cat([r*h, x], dim=1))) + h = (1-z) * h + z * q + + # vertical + hx = torch.cat([h, x], dim=1) + z = torch.sigmoid(self.convz2(hx)) + r = torch.sigmoid(self.convr2(hx)) + q = torch.tanh(self.convq2(torch.cat([r*h, x], dim=1))) + h = (1-z) * h + z * q + + return h + + +def make_model(args, parent=False): + return RAFTNET(args) + +class RAFTNET(nn.Module): + def __init__(self, args, conv=common.default_conv): + super(RAFTNET, self).__init__() + + n_resblocks = args.n_resblocks + n_feats = args.n_feats + kernel_size = 3 + scale = args.scale[0] + + rgb_mean = (0.4488, 0.4371, 0.4040) + rgb_std = (1.0, 1.0, 1.0) + self.sub_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std) + # msa = attention.PyramidAttention() + # define head module + m_head = [conv(args.n_colors, n_feats, kernel_size)] + # perhaps a shallow network here? + for i in range(2): + m_head.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + # convert feature to image, shared + m_tail=[] + for i in range(2): + m_tail.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + m_tail.append(conv(n_feats, args.n_colors, kernel_size)) + # middle recurrent part + # layer = LambdaLayer( + # dim = n_feats, + # dim_out = n_feats, + # r = 23, # the receptive field for relative positional encoding (23 x 23) + # dim_k = 16, + # heads = 4, + # dim_u = 4, + # norm=args.normalization + # ) + # define body module + m_body = [ + common.ResBlock( + conv, n_feats, kernel_size, nn.PReLU(), res_scale=args.res_scale + ) for _ in range(n_resblocks//2) + ] + # m_body.append(layer) + for i in range(n_resblocks//2): + m_body.append(common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale)) + + m_body.append(conv(n_feats, n_feats, kernel_size)) + + self.add_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std, 1) + self.hidden_encoder=nn.Sequential( + common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale), + common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale), + common.ResBlock(conv,n_feats,kernel_size,nn.PReLU(),res_scale=args.res_scale) + ) + self.head = nn.Sequential(*m_head) + self.body = nn.Sequential(*m_body) + self.tail = nn.Sequential(*m_tail) + # self.gru = ConvGRU(hidden_dim=64,input_dim=64) + self.recurrence = args.recurrence + self.detach = args.detach + # self.step_detach = args.step_detach + self.amp = args.amp + + def forward(self, x): + with amp.autocast(self.amp): + x=(x-0.5)/0.5 + x = self.head(x) + hidden = self.hidden_encoder(x) + output_lst=[None]*self.recurrence + for i in range(1): + res=self.body(hidden) + gru_out=res+hidden + output=self.tail(gru_out) + output_lst[i]=output*0.5+0.5 + return output_lst + + def load_state_dict(self, state_dict, strict=True): + own_state = self.state_dict() + for name, param in state_dict.items(): + if name in own_state: + if isinstance(param, nn.Parameter): + param = param.data + try: + own_state[name].copy_(param) + except Exception: + if name.find('tail') == -1: + raise RuntimeError('While copying the parameter named {}, ' + 'whose dimensions in the model are {} and ' + 'whose dimensions in the checkpoint are {}.' + .format(name, own_state[name].size(), param.size())) + elif strict: + if name.find('tail') == -1: + raise KeyError('unexpected key "{}" in state_dict' + .format(name)) + diff --git a/DN_RGB/code/model/utils/__init__.py b/DN_RGB/code/model/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/DN_RGB/code/model/utils/__pycache__/__init__.cpython-35.pyc b/DN_RGB/code/model/utils/__pycache__/__init__.cpython-35.pyc new file mode 100644 index 0000000000000000000000000000000000000000..40f387d415e1f4bb9bf4ceac0a889a9aebc334be Binary files /dev/null and b/DN_RGB/code/model/utils/__pycache__/__init__.cpython-35.pyc differ diff --git a/DN_RGB/code/model/utils/__pycache__/tools.cpython-35.pyc b/DN_RGB/code/model/utils/__pycache__/tools.cpython-35.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a91ca012e6881f1c14b197e62e83607d0e56de35 Binary files /dev/null and b/DN_RGB/code/model/utils/__pycache__/tools.cpython-35.pyc differ diff --git a/DN_RGB/code/model/utils/tools.py b/DN_RGB/code/model/utils/tools.py new file mode 100644 index 0000000000000000000000000000000000000000..c40cd8dc5e95d353254b950c9ec373126c5fe63e --- /dev/null +++ b/DN_RGB/code/model/utils/tools.py @@ -0,0 +1,81 @@ +import os +import torch +import numpy as np +from PIL import Image + +import torch.nn.functional as F + +def normalize(x): + return x.mul_(2).add_(-1) + +def same_padding(images, ksizes, strides, rates): + assert len(images.size()) == 4 + batch_size, channel, rows, cols = images.size() + out_rows = (rows + strides[0] - 1) // strides[0] + out_cols = (cols + strides[1] - 1) // strides[1] + effective_k_row = (ksizes[0] - 1) * rates[0] + 1 + effective_k_col = (ksizes[1] - 1) * rates[1] + 1 + padding_rows = max(0, (out_rows-1)*strides[0]+effective_k_row-rows) + padding_cols = max(0, (out_cols-1)*strides[1]+effective_k_col-cols) + # Pad the input + padding_top = int(padding_rows / 2.) + padding_left = int(padding_cols / 2.) + padding_bottom = padding_rows - padding_top + padding_right = padding_cols - padding_left + paddings = (padding_left, padding_right, padding_top, padding_bottom) + images = torch.nn.ZeroPad2d(paddings)(images) + return images + + +def extract_image_patches(images, ksizes, strides, rates, padding='same'): + """ + Extract patches from images and put them in the C output dimension. + :param padding: + :param images: [batch, channels, in_rows, in_cols]. A 4-D Tensor with shape + :param ksizes: [ksize_rows, ksize_cols]. The size of the sliding window for + each dimension of images + :param strides: [stride_rows, stride_cols] + :param rates: [dilation_rows, dilation_cols] + :return: A Tensor + """ + assert len(images.size()) == 4 + assert padding in ['same', 'valid'] + batch_size, channel, height, width = images.size() + + if padding == 'same': + images = same_padding(images, ksizes, strides, rates) + elif padding == 'valid': + pass + else: + raise NotImplementedError('Unsupported padding type: {}.\ + Only "same" or "valid" are supported.'.format(padding)) + + unfold = torch.nn.Unfold(kernel_size=ksizes, + dilation=rates, + padding=0, + stride=strides) + patches = unfold(images) + return patches # [N, C*k*k, L], L is the total number of such blocks +def reduce_mean(x, axis=None, keepdim=False): + if not axis: + axis = range(len(x.shape)) + for i in sorted(axis, reverse=True): + x = torch.mean(x, dim=i, keepdim=keepdim) + return x + + +def reduce_std(x, axis=None, keepdim=False): + if not axis: + axis = range(len(x.shape)) + for i in sorted(axis, reverse=True): + x = torch.std(x, dim=i, keepdim=keepdim) + return x + + +def reduce_sum(x, axis=None, keepdim=False): + if not axis: + axis = range(len(x.shape)) + for i in sorted(axis, reverse=True): + x = torch.sum(x, dim=i, keepdim=keepdim) + return x + diff --git a/DN_RGB/code/model/vdsr.py b/DN_RGB/code/model/vdsr.py new file mode 100644 index 0000000000000000000000000000000000000000..492442a212aaceee369fc842abcab114d93f2729 --- /dev/null +++ b/DN_RGB/code/model/vdsr.py @@ -0,0 +1,46 @@ +from model import common + +import torch.nn as nn +import torch.nn.init as init + +url = { + 'r20f64': '' +} + +def make_model(args, parent=False): + return VDSR(args) + +class VDSR(nn.Module): + def __init__(self, args, conv=common.default_conv): + super(VDSR, self).__init__() + + n_resblocks = args.n_resblocks + n_feats = args.n_feats + kernel_size = 3 + self.url = url['r{}f{}'.format(n_resblocks, n_feats)] + self.sub_mean = common.MeanShift(args.rgb_range) + self.add_mean = common.MeanShift(args.rgb_range, sign=1) + + def basic_block(in_channels, out_channels, act): + return common.BasicBlock( + conv, in_channels, out_channels, kernel_size, + bias=True, bn=False, act=act + ) + + # define body module + m_body = [] + m_body.append(basic_block(args.n_colors, n_feats, nn.ReLU(True))) + for _ in range(n_resblocks - 2): + m_body.append(basic_block(n_feats, n_feats, nn.ReLU(True))) + m_body.append(basic_block(n_feats, args.n_colors, None)) + + self.body = nn.Sequential(*m_body) + + def forward(self, x): + x = self.sub_mean(x) + res = self.body(x) + res += x + x = self.add_mean(res) + + return x + diff --git a/DN_RGB/code/option.py b/DN_RGB/code/option.py new file mode 100644 index 0000000000000000000000000000000000000000..98bfcecd00a6238105fbbe1f9822bd99eedf959d --- /dev/null +++ b/DN_RGB/code/option.py @@ -0,0 +1,173 @@ +import argparse +import template + +parser = argparse.ArgumentParser(description='EDSR and MDSR') + +parser.add_argument('--debug', action='store_true', + help='Enables debug mode') +parser.add_argument('--template', default='.', + help='You can set various templates in option.py') + +# Hardware specifications +parser.add_argument('--n_threads', type=int, default=18, + help='number of threads for data loading') +parser.add_argument('--cpu', action='store_true', + help='use cpu only') +parser.add_argument('--n_GPUs', type=int, default=1, + help='number of GPUs') +parser.add_argument('--seed', type=int, default=1, + help='random seed') + +# Data specifications +parser.add_argument('--dir_data', type=str, default='/data/ssd/public/liuhy/DNDM/dataset',help='dataset directory') +parser.add_argument('--data_train', type=str, default='DIV2K', + help='train dataset name') +parser.add_argument('--data_test', type=str, default='DIV2K', + help='test dataset name') +parser.add_argument('--data_range', type=str, default='1-800/943-1000', + help='train/test data range') +parser.add_argument('--ext', type=str, default='sep', + help='dataset file extension') +parser.add_argument('--scale', type=str, default='4', + help='super resolution scale') +parser.add_argument('--patch_size', type=int, default=192, + help='output patch size') +parser.add_argument('--rgb_range', type=int, default=1, + help='maximum value of RGB') +parser.add_argument('--n_colors', type=int, default=3, + help='number of color channels to use') +parser.add_argument('--chop', action='store_true', + help='enable memory-efficient forward') +parser.add_argument('--no_augment', action='store_true', + help='do not use data augmentation') + +# Model specifications +parser.add_argument('--model', default='LAMBDANET', + help='model name') + +parser.add_argument('--act', type=str, default='relu', + help='activation function') +parser.add_argument('--pre_train', type=str, default='.', + help='pre-trained model directory') +parser.add_argument('--extend', type=str, default='.', + help='pre-trained model directory') +parser.add_argument('--n_resblocks', type=int, default=16, + help='number of residual blocks') +parser.add_argument('--recurrence', type=int, default=5, + help='number of recurrence') +parser.add_argument('--n_feats', type=int, default=64, + help='number of feature maps') +parser.add_argument('--res_scale', type=float, default=1, + help='residual scaling') +parser.add_argument('--shift_mean', default=True, + help='subtract pixel mean from the input') +parser.add_argument('--amp', action='store_true', + help='subtract pixel mean from the input') +parser.add_argument('--detach', action='store_true', + help='subtract pixel mean from the input') +parser.add_argument('--spectral', action='store_true', + help='subtract pixel mean from the input') +parser.add_argument('--dilation', action='store_true', + help='use dilated convolution') +parser.add_argument('--precision', type=str, default='single', + choices=('single', 'half'), + help='FP precision for test (single | half)') +parser.add_argument('--normalization', type=str, default='batch') +parser.add_argument('--lamradius', type=int, default=23) +parser.add_argument('--decay_gamma', type=float, default=0.8) +# parser.add_argument('--lamres', action='store_true', + # help='subtract pixel mean from the input') + +# Option for Residual dense network (RDN) +parser.add_argument('--G0', type=int, default=64, + help='default number of filters. (Use in RDN)') +parser.add_argument('--RDNkSize', type=int, default=3, + help='default kernel size. (Use in RDN)') +parser.add_argument('--RDNconfig', type=str, default='B', + help='parameters config of RDN. (Use in RDN)') + +parser.add_argument('--depth', type=int, default=12, + help='number of residual groups') +# Option for Residual channel attention network (RCAN) +parser.add_argument('--n_resgroups', type=int, default=10, + help='number of residual groups') +parser.add_argument('--reduction', type=int, default=16, + help='number of feature maps reduction') + +# Training specifications +parser.add_argument('--reset', action='store_true', + help='reset the training') +parser.add_argument('--test_every', type=int, default=1000, + help='do test per every N batches') +parser.add_argument('--epochs', type=int, default=1000, + help='number of epochs to train') +parser.add_argument('--batch_size', type=int, default=16, + help='input batch size for training') +parser.add_argument('--split_batch', type=int, default=1, + help='split the batch into smaller chunks') +parser.add_argument('--self_ensemble', action='store_true', + help='use self-ensemble method for test') +parser.add_argument('--test_only', action='store_true', + help='set this option to test the model') +parser.add_argument('--gan_k', type=int, default=1, + help='k value for adversarial loss') + +# Optimization specifications +parser.add_argument('--lr', type=float, default=1e-4, + help='learning rate') +parser.add_argument('--decay', type=str, default='200-400-600-800', + help='learning rate decay type') +parser.add_argument('--gamma', type=float, default=0.5, + help='learning rate decay factor for step decay') +parser.add_argument('--optimizer', default='ADAM', + choices=('SGD', 'ADAM', 'RMSprop', "ADAMW"), + help='optimizer to use (SGD | ADAM | RMSprop)') +parser.add_argument('--momentum', type=float, default=0.9, + help='SGD momentum') +parser.add_argument('--betas', type=tuple, default=(0.9, 0.999), + help='ADAM beta') +parser.add_argument('--epsilon', type=float, default=1e-8, + help='ADAM epsilon for numerical stability') +parser.add_argument('--weight_decay', type=float, default=0, + help='weight decay') +parser.add_argument('--gclip', type=float, default=0, + help='gradient clipping threshold (0 = no clipping)') + +# Loss specifications +parser.add_argument('--loss', type=str, default='1*L1', + help='loss function configuration') +parser.add_argument('--skip_threshold', type=float, default='1e8', + help='skipping batch that has large error') + +# Log specifications +parser.add_argument('--save', type=str, default='test', + help='file name to save') +parser.add_argument('--load', type=str, default='', + help='file name to load') +parser.add_argument('--resume', type=int, default=0, + help='resume from specific checkpoint') +parser.add_argument('--save_models', action='store_true', + help='save all intermediate models') +parser.add_argument('--print_every', type=int, default=100, + help='how many batches to wait before logging training status') +parser.add_argument('--save_results', action='store_true', + help='save output results') +parser.add_argument('--save_gt', action='store_true', + help='save low-resolution and high-resolution images together') + +args = parser.parse_args() +template.set_template(args) + +args.scale = list(map(lambda x: int(x), args.scale.split('+'))) +args.data_train = args.data_train.split('+') +args.data_test = args.data_test.split('+') + +if args.epochs == 0: + args.epochs = 1e8 + +for arg in vars(args): + if vars(args)[arg] == 'True': + vars(args)[arg] = True + elif vars(args)[arg] == 'False': + vars(args)[arg] = False + diff --git a/DN_RGB/code/prepare.sh b/DN_RGB/code/prepare.sh new file mode 100644 index 0000000000000000000000000000000000000000..adecc455029e50fffb92dcc2ecf059583be2ac92 --- /dev/null +++ b/DN_RGB/code/prepare.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +username=`whoami` +task="DNDM" + +if [ ! -d "/data/ssd/public/$username/$task/dataset" ]; then + workplace=`pwd -P` + echo "Copying dataset to ssd" + cd /research/dept7/liuhy/lambda/$task + mkdir -p /data/ssd/public/$username/$task/dataset + cp *.tar /data/ssd/public/$username/$task/dataset + cd "/data/ssd/public/$username/$task/dataset" + echo "Dumping tar in data path:" `pwd` + for f in *.tar; do tar xf "$f"; done + cd "$workplace" + echo "Workplace:" `pwd` +fi \ No newline at end of file diff --git a/DN_RGB/code/runs/GRUNET_N50_R4_nobn/events.out.tfevents.1607098393.gpu26.cse.cuhk.edu.hk.156236.0 b/DN_RGB/code/runs/GRUNET_N50_R4_nobn/events.out.tfevents.1607098393.gpu26.cse.cuhk.edu.hk.156236.0 new file mode 100644 index 0000000000000000000000000000000000000000..4361ca0daef1f69bbcf6948469824bb81d22a9e2 --- /dev/null +++ b/DN_RGB/code/runs/GRUNET_N50_R4_nobn/events.out.tfevents.1607098393.gpu26.cse.cuhk.edu.hk.156236.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ff9f8edece505703d9b2e92eb0d18c116a61b2b29348513b44fdeb9fa36afac5 +size 36582582 diff --git a/DN_RGB/code/runs/RAFTS_N50/events.out.tfevents.1604921900.projgpu3.cse.cuhk.edu.hk.18800.0 b/DN_RGB/code/runs/RAFTS_N50/events.out.tfevents.1604921900.projgpu3.cse.cuhk.edu.hk.18800.0 new file mode 100644 index 0000000000000000000000000000000000000000..c4e8288aeeeb9a86c430eb1127d1356c0d7137dc --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50/events.out.tfevents.1604921900.projgpu3.cse.cuhk.edu.hk.18800.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9418c30aa9c687b79bfb9d34078c7ac79736c499cbd6ee4ab554d35b7550d0aa +size 40 diff --git a/DN_RGB/code/runs/RAFTS_N50/events.out.tfevents.1604921919.projgpu3.cse.cuhk.edu.hk.19080.0 b/DN_RGB/code/runs/RAFTS_N50/events.out.tfevents.1604921919.projgpu3.cse.cuhk.edu.hk.19080.0 new file mode 100644 index 0000000000000000000000000000000000000000..53b428c731430d23b38faa312ba316e68a6f6236 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50/events.out.tfevents.1604921919.projgpu3.cse.cuhk.edu.hk.19080.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d4f80eb2d6c724f789c8b21ab340287d9c6729ab170e54cef505644187147f1d +size 35290445 diff --git a/DN_RGB/code/runs/RAFTS_N50/events.out.tfevents.1605002334.gpu22.cse.cuhk.edu.hk.170772.0 b/DN_RGB/code/runs/RAFTS_N50/events.out.tfevents.1605002334.gpu22.cse.cuhk.edu.hk.170772.0 new file mode 100644 index 0000000000000000000000000000000000000000..c2ab2b4fb632f39d106af28999691ee6df12c056 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50/events.out.tfevents.1605002334.gpu22.cse.cuhk.edu.hk.170772.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e1fb01f277c6b29de75b44c3cc00447eaaa7fc4241114a61d1d0a608e0a9e16a +size 11729149 diff --git a/DN_RGB/code/runs/RAFTS_N50_R3_layer_r3/events.out.tfevents.1605455214.gpu5.cse.cuhk.edu.hk.1981.0 b/DN_RGB/code/runs/RAFTS_N50_R3_layer_r3/events.out.tfevents.1605455214.gpu5.cse.cuhk.edu.hk.1981.0 new file mode 100644 index 0000000000000000000000000000000000000000..a96f31cce878cc7bc156008ba642d35cc2d7daae --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R3_layer_r3/events.out.tfevents.1605455214.gpu5.cse.cuhk.edu.hk.1981.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5e855cfbdfa7d1d4eadde8aa3b1f4482dbcef54ab2fb7237a76632c40a88f6fd +size 41252789 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_bn/events.out.tfevents.1605082008.gpu48.cse.cuhk.edu.hk.21255.0 b/DN_RGB/code/runs/RAFTS_N50_R4_bn/events.out.tfevents.1605082008.gpu48.cse.cuhk.edu.hk.21255.0 new file mode 100644 index 0000000000000000000000000000000000000000..bb6ece8e2cefc933c3461793f38fd6fc7187d458 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_bn/events.out.tfevents.1605082008.gpu48.cse.cuhk.edu.hk.21255.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f83941fd7c9d74a4b320fbe0cf82fff9ed18b564c0143957b8bcd16ccafabe92 +size 53270436 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_bn/events.out.tfevents.1605167149.gpu22.cse.cuhk.edu.hk.199401.0 b/DN_RGB/code/runs/RAFTS_N50_R4_bn/events.out.tfevents.1605167149.gpu22.cse.cuhk.edu.hk.199401.0 new file mode 100644 index 0000000000000000000000000000000000000000..9c427449f2dfd757c036120b0d65cfff1f5b5613 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_bn/events.out.tfevents.1605167149.gpu22.cse.cuhk.edu.hk.199401.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:48985a51706b8e44b51edd244c904442ebb775a9896c3f294310638d05c81dc5 +size 25104395 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_bn/events.out.tfevents.1605367962.gpu1.cse.cuhk.edu.hk.189959.0 b/DN_RGB/code/runs/RAFTS_N50_R4_bn/events.out.tfevents.1605367962.gpu1.cse.cuhk.edu.hk.189959.0 new file mode 100644 index 0000000000000000000000000000000000000000..fd4b9a9158437c86fc81d2ca199f93daae7492cd --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_bn/events.out.tfevents.1605367962.gpu1.cse.cuhk.edu.hk.189959.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9555daf6f0359351224faa7fca8a501d556d9790a8e3d1712b95b69aa6eb51a2 +size 19213486 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_bn_small/events.out.tfevents.1605082190.gpu22.cse.cuhk.edu.hk.236610.0 b/DN_RGB/code/runs/RAFTS_N50_R4_bn_small/events.out.tfevents.1605082190.gpu22.cse.cuhk.edu.hk.236610.0 new file mode 100644 index 0000000000000000000000000000000000000000..2a1032e8538549082460a7dd618c17515cf8b3d8 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_bn_small/events.out.tfevents.1605082190.gpu22.cse.cuhk.edu.hk.236610.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6708431bf92a14cb9ae14055d1bc67fb834bfb13d533f14ddd18cad05d267783 +size 40 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_in/events.out.tfevents.1605082096.gpu22.cse.cuhk.edu.hk.236019.0 b/DN_RGB/code/runs/RAFTS_N50_R4_in/events.out.tfevents.1605082096.gpu22.cse.cuhk.edu.hk.236019.0 new file mode 100644 index 0000000000000000000000000000000000000000..91d86a49dd3661b4d0a848a4a4cd8b9693736c71 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_in/events.out.tfevents.1605082096.gpu22.cse.cuhk.edu.hk.236019.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:350fba54d8d4fc333fd03e22ea8749a871b3427c0197374222dbae1139170143 +size 25389358 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_in/events.out.tfevents.1605166428.gpu48.cse.cuhk.edu.hk.8473.0 b/DN_RGB/code/runs/RAFTS_N50_R4_in/events.out.tfevents.1605166428.gpu48.cse.cuhk.edu.hk.8473.0 new file mode 100644 index 0000000000000000000000000000000000000000..de0bd1fe80bf7d5d2f5be672c43f5cf4ff463a19 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_in/events.out.tfevents.1605166428.gpu48.cse.cuhk.edu.hk.8473.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:784bf9636baa3ebb7d74749835412ba606b73403c5dd66e9d40250a3954649ea +size 6886988 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_in/events.out.tfevents.1605175653.gpu48.cse.cuhk.edu.hk.25999.0 b/DN_RGB/code/runs/RAFTS_N50_R4_in/events.out.tfevents.1605175653.gpu48.cse.cuhk.edu.hk.25999.0 new file mode 100644 index 0000000000000000000000000000000000000000..e513745d0e1149ad64ec1794685bb9238559bae3 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_in/events.out.tfevents.1605175653.gpu48.cse.cuhk.edu.hk.25999.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a820525818d42c18ac9817da473693ee7828c036a38812ddca1675b24415e742 +size 1134886 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_ln/events.out.tfevents.1605082050.gpu48.cse.cuhk.edu.hk.21398.0 b/DN_RGB/code/runs/RAFTS_N50_R4_ln/events.out.tfevents.1605082050.gpu48.cse.cuhk.edu.hk.21398.0 new file mode 100644 index 0000000000000000000000000000000000000000..7900ec3d96a89d84d34a6ed1b935c41a15fcddfd --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_ln/events.out.tfevents.1605082050.gpu48.cse.cuhk.edu.hk.21398.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dd72f2f01f432cad2549d7ab13bcc09985be7f9689fbcc59f66426cfeb2bb743 +size 15258127 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_ln_clip/events.out.tfevents.1605103155.gpu48.cse.cuhk.edu.hk.20848.0 b/DN_RGB/code/runs/RAFTS_N50_R4_ln_clip/events.out.tfevents.1605103155.gpu48.cse.cuhk.edu.hk.20848.0 new file mode 100644 index 0000000000000000000000000000000000000000..658895c015c4783e2443d40d0eb37a4ee3a96fc0 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_ln_clip/events.out.tfevents.1605103155.gpu48.cse.cuhk.edu.hk.20848.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0d1a4973ac62469cbabed7c6ad2d379221acae9c5b52e229f32413fdaf2db6d9 +size 5561926 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_ln_clip/events.out.tfevents.1605166643.gpu48.cse.cuhk.edu.hk.9093.0 b/DN_RGB/code/runs/RAFTS_N50_R4_ln_clip/events.out.tfevents.1605166643.gpu48.cse.cuhk.edu.hk.9093.0 new file mode 100644 index 0000000000000000000000000000000000000000..95d4b2124d6210635e3e5393f4b87515bbd769e3 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_ln_clip/events.out.tfevents.1605166643.gpu48.cse.cuhk.edu.hk.9093.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e64f5f3b914b4c43a693541248058f48d6a7ee6f695fb20f8990f253ae8f0ee4 +size 56817888 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_ln_large/events.out.tfevents.1605082498.gpu22.cse.cuhk.edu.hk.237302.0 b/DN_RGB/code/runs/RAFTS_N50_R4_ln_large/events.out.tfevents.1605082498.gpu22.cse.cuhk.edu.hk.237302.0 new file mode 100644 index 0000000000000000000000000000000000000000..f736c4a7af803f5ec3667c3ce1119f788bcb2442 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_ln_large/events.out.tfevents.1605082498.gpu22.cse.cuhk.edu.hk.237302.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a681051e1cdacffde23b1a8ac5215a3e75a5bae9ba8cba2490de72058f0f533d +size 40 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_ln_res10/events.out.tfevents.1605082163.gpu22.cse.cuhk.edu.hk.236312.0 b/DN_RGB/code/runs/RAFTS_N50_R4_ln_res10/events.out.tfevents.1605082163.gpu22.cse.cuhk.edu.hk.236312.0 new file mode 100644 index 0000000000000000000000000000000000000000..93a6f44d841d40bea6fc7b6f2d94c374da9c3c09 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_ln_res10/events.out.tfevents.1605082163.gpu22.cse.cuhk.edu.hk.236312.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f6befe6986af80edc2cb124307846082be0c940837b4f8090c0bbda705228a6e +size 869083 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_ln_res10/events.out.tfevents.1605086773.gpu22.cse.cuhk.edu.hk.246835.0 b/DN_RGB/code/runs/RAFTS_N50_R4_ln_res10/events.out.tfevents.1605086773.gpu22.cse.cuhk.edu.hk.246835.0 new file mode 100644 index 0000000000000000000000000000000000000000..9e2079842bce95ed16227df0a29b64a0f10608e4 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_ln_res10/events.out.tfevents.1605086773.gpu22.cse.cuhk.edu.hk.246835.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e692825b30adbb9499af4b656193370b31aec0b92078d0c99098ab5a73da1a5e +size 40 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_ln_small/events.out.tfevents.1605082584.gpu22.cse.cuhk.edu.hk.237675.0 b/DN_RGB/code/runs/RAFTS_N50_R4_ln_small/events.out.tfevents.1605082584.gpu22.cse.cuhk.edu.hk.237675.0 new file mode 100644 index 0000000000000000000000000000000000000000..d5885d3c7cf3930679e4e3ce852146185134940f --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_ln_small/events.out.tfevents.1605082584.gpu22.cse.cuhk.edu.hk.237675.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d281f5da5306b4f7bb4bb761658ee3e515f33dcb27252bd0c62d723f72f4ee97 +size 16044250 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605081945.gpu48.cse.cuhk.edu.hk.20973.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605081945.gpu48.cse.cuhk.edu.hk.20973.0 new file mode 100644 index 0000000000000000000000000000000000000000..93bb2f8a58a7315cef11c1b0e9ad96a8a87153bc --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605081945.gpu48.cse.cuhk.edu.hk.20973.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d1dea46fb5ca70c4b1860352b2c91a968f1ae5283a07f1ed25d730356a660941 +size 51473563 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605166721.gpu48.cse.cuhk.edu.hk.9511.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605166721.gpu48.cse.cuhk.edu.hk.9511.0 new file mode 100644 index 0000000000000000000000000000000000000000..825415466202d733d604a447ffa30c5ce7bcbba0 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605166721.gpu48.cse.cuhk.edu.hk.9511.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8ee42c300ffee5b8f449e58621b25850b182377bfeb21339bf26056c79b95c2d +size 6628893 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605177154.gpu48.cse.cuhk.edu.hk.29089.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605177154.gpu48.cse.cuhk.edu.hk.29089.0 new file mode 100644 index 0000000000000000000000000000000000000000..128eeb779d00368b68648300f3b1e95af8cdc55d --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605177154.gpu48.cse.cuhk.edu.hk.29089.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eddb1110a7796b21c0502d8c5347e81dc18c8820aad73558e8a3e94a7d6733b6 +size 24189653 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605231401.gpu48.cse.cuhk.edu.hk.6929.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605231401.gpu48.cse.cuhk.edu.hk.6929.0 new file mode 100644 index 0000000000000000000000000000000000000000..64a775f801556afb5c2b7e072a845089f6666881 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605231401.gpu48.cse.cuhk.edu.hk.6929.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d7e1918e303fc5c593ee2b1eee18d22cad2deb49f9338d9cdd9e16b1732aea67 +size 5434168 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605251315.gpu48.cse.cuhk.edu.hk.22780.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605251315.gpu48.cse.cuhk.edu.hk.22780.0 new file mode 100644 index 0000000000000000000000000000000000000000..18624eb1f7836924325e8eabcd591440925bfe8d --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605251315.gpu48.cse.cuhk.edu.hk.22780.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c23da531ea73783383b46fca69cd15797c4484eeab69fa0d25abe95b8a7bda19 +size 14398737 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605271692.gpu48.cse.cuhk.edu.hk.17849.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605271692.gpu48.cse.cuhk.edu.hk.17849.0 new file mode 100644 index 0000000000000000000000000000000000000000..da5c5b5dba4ca89e1343544f05a52f7efe78af40 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605271692.gpu48.cse.cuhk.edu.hk.17849.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2af2ebda9c660873f4fa1d14928421bf99f55f5d3a3854bc94cfcedbac8e6786 +size 15435301 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605314439.gpu48.cse.cuhk.edu.hk.18527.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605314439.gpu48.cse.cuhk.edu.hk.18527.0 new file mode 100644 index 0000000000000000000000000000000000000000..f7aa93143262892ee10e0988ccf70535dee74dcc --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605314439.gpu48.cse.cuhk.edu.hk.18527.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cc7f83d9db71281b62671470e013ffbce3412e6be7d3ac34c03d06198ab52a2c +size 10063628 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605345413.gpu1.cse.cuhk.edu.hk.82346.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605345413.gpu1.cse.cuhk.edu.hk.82346.0 new file mode 100644 index 0000000000000000000000000000000000000000..a0aac33db9825ad28c921fe9f2a17aced0a97bbd --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605345413.gpu1.cse.cuhk.edu.hk.82346.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c60650de546f277e65b8ad6e8b1d2a39dbc5386e41f1b4074b26861292fe6bc2 +size 14033466 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605444565.gpu1.cse.cuhk.edu.hk.98316.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605444565.gpu1.cse.cuhk.edu.hk.98316.0 new file mode 100644 index 0000000000000000000000000000000000000000..e784f41340662cdd84e7114ffbdff2c9467b22e7 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1605444565.gpu1.cse.cuhk.edu.hk.98316.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:58eb02b833e6e818b254fefdf1cb44b5b42d543ac0320692cb3a707b5f8c5f0a +size 37618348 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1612280948.gpu5.cse.cuhk.edu.hk.72392.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1612280948.gpu5.cse.cuhk.edu.hk.72392.0 new file mode 100644 index 0000000000000000000000000000000000000000..d774f58bb2cf340fd23ee10d2cf276d186142a79 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn/events.out.tfevents.1612280948.gpu5.cse.cuhk.edu.hk.72392.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:97049aa63d89b08a3984d46da3c31edb11c5f812c97182fb2ec9ccdb5aa28bb9 +size 46995146 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn_nores/events.out.tfevents.1605110578.gpu48.cse.cuhk.edu.hk.34903.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_nores/events.out.tfevents.1605110578.gpu48.cse.cuhk.edu.hk.34903.0 new file mode 100644 index 0000000000000000000000000000000000000000..b9077c8d302a93a2dc1a76c419ddf78f4fd22d13 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_nores/events.out.tfevents.1605110578.gpu48.cse.cuhk.edu.hk.34903.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:93685fe44575b0598c76a0394aab831c8df7593c69d09ecffccaeea3e29e421a +size 33546020 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn_nores/events.out.tfevents.1605167228.gpu22.cse.cuhk.edu.hk.199644.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_nores/events.out.tfevents.1605167228.gpu22.cse.cuhk.edu.hk.199644.0 new file mode 100644 index 0000000000000000000000000000000000000000..3ff8b459fd1d1461a5f7d316a16c21ce8d276bcf --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_nores/events.out.tfevents.1605167228.gpu22.cse.cuhk.edu.hk.199644.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:54ac8f32877c4d208db1a040f034cd33bfcfd756c94e2d0413eaf756974fdebf +size 25068205 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r3_detach0.6/events.out.tfevents.1605283511.gpu6.cse.cuhk.edu.hk.109019.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r3_detach0.6/events.out.tfevents.1605283511.gpu6.cse.cuhk.edu.hk.109019.0 new file mode 100644 index 0000000000000000000000000000000000000000..9073fdefe8c2c2458a9fe64584c7e4e91f685b5b --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r3_detach0.6/events.out.tfevents.1605283511.gpu6.cse.cuhk.edu.hk.109019.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a60fe0699fad0c0b41fc713eb3764761de3042ca5c6883d1b15b2a8c222420e6 +size 36721150 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7/events.out.tfevents.1605283106.gpu6.cse.cuhk.edu.hk.107590.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7/events.out.tfevents.1605283106.gpu6.cse.cuhk.edu.hk.107590.0 new file mode 100644 index 0000000000000000000000000000000000000000..2660f75497469c33f79dfc67a2dce84b5c569973 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7/events.out.tfevents.1605283106.gpu6.cse.cuhk.edu.hk.107590.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:42c0ba6d4518c583844fbd1651251e43d3b270f49cbc476c18516c450807ce27 +size 40539341 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7/events.out.tfevents.1605367580.gpu5.cse.cuhk.edu.hk.122192.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7/events.out.tfevents.1605367580.gpu5.cse.cuhk.edu.hk.122192.0 new file mode 100644 index 0000000000000000000000000000000000000000..5da1af256b022ce18d8071ff63088faa6b9de0dc --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7/events.out.tfevents.1605367580.gpu5.cse.cuhk.edu.hk.122192.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ef808672fef8647229c2599463264d334f9ca284b94747bec7a104be99a1acfa +size 41203812 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7/events.out.tfevents.1605455054.gpu5.cse.cuhk.edu.hk.1551.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7/events.out.tfevents.1605455054.gpu5.cse.cuhk.edu.hk.1551.0 new file mode 100644 index 0000000000000000000000000000000000000000..beec6f92e7181e7a68b87939309f198b65379191 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7/events.out.tfevents.1605455054.gpu5.cse.cuhk.edu.hk.1551.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9052f2a571cdd26418398fd138540e861b8a0f6ea6ffa201f9c0685d3f76c338 +size 37665260 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7_detach/events.out.tfevents.1605283255.gpu6.cse.cuhk.edu.hk.108099.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7_detach/events.out.tfevents.1605283255.gpu6.cse.cuhk.edu.hk.108099.0 new file mode 100644 index 0000000000000000000000000000000000000000..803512bd544e2fd65d16d06b00ddeb5a9edb38f2 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7_detach/events.out.tfevents.1605283255.gpu6.cse.cuhk.edu.hk.108099.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d185b87676bf0cbb7958cd06ecd6afe9435cda6d5294e37a4e53f380f783b411 +size 40189220 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7_detach/events.out.tfevents.1605368236.gpu5.cse.cuhk.edu.hk.123857.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7_detach/events.out.tfevents.1605368236.gpu5.cse.cuhk.edu.hk.123857.0 new file mode 100644 index 0000000000000000000000000000000000000000..122be05f80664ef74c7325a84cfe865aecdc6e26 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7_detach/events.out.tfevents.1605368236.gpu5.cse.cuhk.edu.hk.123857.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d31bd0a01f1b6a6a9e7c90ec33724aef1941f07f2b905f629b9201bbc814d57c +size 39686389 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7_detach_res/events.out.tfevents.1605284007.gpu6.cse.cuhk.edu.hk.110598.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7_detach_res/events.out.tfevents.1605284007.gpu6.cse.cuhk.edu.hk.110598.0 new file mode 100644 index 0000000000000000000000000000000000000000..79f361ec45c068407faf0a484b4cfe928491a24e --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7_detach_res/events.out.tfevents.1605284007.gpu6.cse.cuhk.edu.hk.110598.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d1d0bc38098fa6f23be241437da295409b244f6e7610d34a015ce9740cec65cc +size 40 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7_detach_res/events.out.tfevents.1605284086.gpu6.cse.cuhk.edu.hk.110764.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7_detach_res/events.out.tfevents.1605284086.gpu6.cse.cuhk.edu.hk.110764.0 new file mode 100644 index 0000000000000000000000000000000000000000..6179f2ab0b2e54d03847b443ffec0881e7d20e1e --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7_detach_res/events.out.tfevents.1605284086.gpu6.cse.cuhk.edu.hk.110764.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:de57db7499193549766d71a1bc134f529f582dd745dacdcb86c959333fb63cba +size 40 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7_detach_res/events.out.tfevents.1605284190.gpu6.cse.cuhk.edu.hk.111111.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7_detach_res/events.out.tfevents.1605284190.gpu6.cse.cuhk.edu.hk.111111.0 new file mode 100644 index 0000000000000000000000000000000000000000..65b97a4e373d072d4cc701b65e719bd159ae4b7d --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7_detach_res/events.out.tfevents.1605284190.gpu6.cse.cuhk.edu.hk.111111.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:262b432b65c6334d58e404e3bafdcd16ad49ab66ac43df040ad17318a818ba25 +size 42969529 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7_detach_res/events.out.tfevents.1605368248.gpu5.cse.cuhk.edu.hk.124065.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7_detach_res/events.out.tfevents.1605368248.gpu5.cse.cuhk.edu.hk.124065.0 new file mode 100644 index 0000000000000000000000000000000000000000..f13671bcc45b014553725acffee9d960fcddda53 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_r7_detach_res/events.out.tfevents.1605368248.gpu5.cse.cuhk.edu.hk.124065.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:76ddd3aba18390a28a29f739a69b549a22c2b0a14fbf36af22f22ee2679d465f +size 40660656 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn_re/events.out.tfevents.1605367904.gpu1.cse.cuhk.edu.hk.189484.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_re/events.out.tfevents.1605367904.gpu1.cse.cuhk.edu.hk.189484.0 new file mode 100644 index 0000000000000000000000000000000000000000..6e4cdd3acc66196ad1cc574816e16441b93de581 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_re/events.out.tfevents.1605367904.gpu1.cse.cuhk.edu.hk.189484.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f496905649402bcbdc6199d2faf49c4314f071448d3b5a2571087d2a31dbea29 +size 19214617 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn_res10/events.out.tfevents.1605086904.gpu22.cse.cuhk.edu.hk.247584.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_res10/events.out.tfevents.1605086904.gpu22.cse.cuhk.edu.hk.247584.0 new file mode 100644 index 0000000000000000000000000000000000000000..d1bc7419f963bf6dfdb6196459fecb392389bc9e --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_res10/events.out.tfevents.1605086904.gpu22.cse.cuhk.edu.hk.247584.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:00e98bb88c59ce4890389bee49d06c5619a4b735497854ed69aeebe3eb5ad6ca +size 40 diff --git a/DN_RGB/code/runs/RAFTS_N50_R4_nobn_res40/events.out.tfevents.1605281537.gpu48.cse.cuhk.edu.hk.3927.0 b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_res40/events.out.tfevents.1605281537.gpu48.cse.cuhk.edu.hk.3927.0 new file mode 100644 index 0000000000000000000000000000000000000000..1ebee28557204445d2dd0c62d27942282389720c --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R4_nobn_res40/events.out.tfevents.1605281537.gpu48.cse.cuhk.edu.hk.3927.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:69cdadc645ba31c3058f4d151c897d77137203b32befdbd42b0630c2c0732145 +size 26274213 diff --git a/DN_RGB/code/runs/RAFTS_N50_R8_nobn_res8/events.out.tfevents.1605255542.gpu48.cse.cuhk.edu.hk.11182.0 b/DN_RGB/code/runs/RAFTS_N50_R8_nobn_res8/events.out.tfevents.1605255542.gpu48.cse.cuhk.edu.hk.11182.0 new file mode 100644 index 0000000000000000000000000000000000000000..b4565b45373effc4309b6c0bb4f8930179b8147f --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R8_nobn_res8/events.out.tfevents.1605255542.gpu48.cse.cuhk.edu.hk.11182.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:786902a8442398bd8ac6355c1fb47ec58737d59996c2b695e58ab5e0c4a4e648 +size 718489 diff --git a/DN_RGB/code/runs/RAFTS_N50_R8_nobn_res8/events.out.tfevents.1605256874.gpu48.cse.cuhk.edu.hk.20151.0 b/DN_RGB/code/runs/RAFTS_N50_R8_nobn_res8/events.out.tfevents.1605256874.gpu48.cse.cuhk.edu.hk.20151.0 new file mode 100644 index 0000000000000000000000000000000000000000..4bcd7afe60c8feba6934dc6b8e029ee4bea0f9ee --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_N50_R8_nobn_res8/events.out.tfevents.1605256874.gpu48.cse.cuhk.edu.hk.20151.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1b923b121293767922fc442f578ec622c8fcaf047fe42a05f363c1cd3d6c70ec +size 26175305 diff --git a/DN_RGB/code/runs/RAFTS_TANH_N50/events.out.tfevents.1604922122.projgpu3.cse.cuhk.edu.hk.19695.0 b/DN_RGB/code/runs/RAFTS_TANH_N50/events.out.tfevents.1604922122.projgpu3.cse.cuhk.edu.hk.19695.0 new file mode 100644 index 0000000000000000000000000000000000000000..88d20bebb2d6b43e046eaa33af80a6a2b2a50451 --- /dev/null +++ b/DN_RGB/code/runs/RAFTS_TANH_N50/events.out.tfevents.1604922122.projgpu3.cse.cuhk.edu.hk.19695.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0001c9eba6360fefc84090dacb06906bf36e7ee78d216e8a4f909e5615216c70 +size 34904145 diff --git a/DN_RGB/code/runs/test/events.out.tfevents.1605168991.gpu22.cse.cuhk.edu.hk.201971.0 b/DN_RGB/code/runs/test/events.out.tfevents.1605168991.gpu22.cse.cuhk.edu.hk.201971.0 new file mode 100644 index 0000000000000000000000000000000000000000..c68f2377c668b54c86c49ece89517b9d6e6cdb5b --- /dev/null +++ b/DN_RGB/code/runs/test/events.out.tfevents.1605168991.gpu22.cse.cuhk.edu.hk.201971.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2fd3513b074782a399cc36d8b72a286299e72e5238330b206db7acdab3add15f +size 40 diff --git a/DN_RGB/code/runs/test/events.out.tfevents.1605169075.gpu22.cse.cuhk.edu.hk.202603.0 b/DN_RGB/code/runs/test/events.out.tfevents.1605169075.gpu22.cse.cuhk.edu.hk.202603.0 new file mode 100644 index 0000000000000000000000000000000000000000..d2b1243167cf3350a8fa373ff18febab96401821 --- /dev/null +++ b/DN_RGB/code/runs/test/events.out.tfevents.1605169075.gpu22.cse.cuhk.edu.hk.202603.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cc43dace981f7de44941194310c864c3c30d336d62e812bcfbb6eed2002c8275 +size 40 diff --git a/DN_RGB/code/runs/test/events.out.tfevents.1605169272.gpu22.cse.cuhk.edu.hk.203067.0 b/DN_RGB/code/runs/test/events.out.tfevents.1605169272.gpu22.cse.cuhk.edu.hk.203067.0 new file mode 100644 index 0000000000000000000000000000000000000000..a0bc89f4547b1351f2848ec0c66625a4fbd7a995 --- /dev/null +++ b/DN_RGB/code/runs/test/events.out.tfevents.1605169272.gpu22.cse.cuhk.edu.hk.203067.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:729e60eef368da1df4dc2a8f0bb42336b8bb62f7f20c58673a3e7c0cbb436cdb +size 40 diff --git a/DN_RGB/code/runs/test/events.out.tfevents.1605179519.gpu22.cse.cuhk.edu.hk.217528.0 b/DN_RGB/code/runs/test/events.out.tfevents.1605179519.gpu22.cse.cuhk.edu.hk.217528.0 new file mode 100644 index 0000000000000000000000000000000000000000..674feb65861466c6a8e75ed4888285285b3f1ca7 --- /dev/null +++ b/DN_RGB/code/runs/test/events.out.tfevents.1605179519.gpu22.cse.cuhk.edu.hk.217528.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3391b1245090833aea37465ec3ffeb8ea4ff040f3e1ba986d6e13b2bf21ed759 +size 40 diff --git a/DN_RGB/code/runs/test/events.out.tfevents.1605179534.gpu22.cse.cuhk.edu.hk.217683.0 b/DN_RGB/code/runs/test/events.out.tfevents.1605179534.gpu22.cse.cuhk.edu.hk.217683.0 new file mode 100644 index 0000000000000000000000000000000000000000..3a7228204a1fb2ac172dcf67ceb35c2706a57b8b --- /dev/null +++ b/DN_RGB/code/runs/test/events.out.tfevents.1605179534.gpu22.cse.cuhk.edu.hk.217683.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a121a789130742aa93cebb6217c8eecf88e092062008c44a82a2da4b430f8801 +size 40 diff --git a/DN_RGB/code/runs/test/events.out.tfevents.1605186731.gpu22.cse.cuhk.edu.hk.228672.0 b/DN_RGB/code/runs/test/events.out.tfevents.1605186731.gpu22.cse.cuhk.edu.hk.228672.0 new file mode 100644 index 0000000000000000000000000000000000000000..7c8c49aeddbc67348b82896fec0a75cc99eeb8b3 --- /dev/null +++ b/DN_RGB/code/runs/test/events.out.tfevents.1605186731.gpu22.cse.cuhk.edu.hk.228672.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2d756a681ef271eed2e2297ea1a14b622e4ac15547b784d67b95ba827e2a5327 +size 40 diff --git a/DN_RGB/code/runs/test/events.out.tfevents.1605188214.gpu22.cse.cuhk.edu.hk.230694.0 b/DN_RGB/code/runs/test/events.out.tfevents.1605188214.gpu22.cse.cuhk.edu.hk.230694.0 new file mode 100644 index 0000000000000000000000000000000000000000..81b620643b5cdd715fe54f2ffe964a756d1d0652 --- /dev/null +++ b/DN_RGB/code/runs/test/events.out.tfevents.1605188214.gpu22.cse.cuhk.edu.hk.230694.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e03c0a0cf53dfc59f9df6521b963830f54cde164406ebef3e24802e09b20cf7d +size 40 diff --git a/DN_RGB/code/runs/test/events.out.tfevents.1605189900.gpu22.cse.cuhk.edu.hk.233120.0 b/DN_RGB/code/runs/test/events.out.tfevents.1605189900.gpu22.cse.cuhk.edu.hk.233120.0 new file mode 100644 index 0000000000000000000000000000000000000000..da0d5bff1e893c184db9dbfc3793110554c9ae33 --- /dev/null +++ b/DN_RGB/code/runs/test/events.out.tfevents.1605189900.gpu22.cse.cuhk.edu.hk.233120.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d719ce0b947668b96d5ff20388a6707f9e10f38331504223793f8b35732cede9 +size 40 diff --git a/DN_RGB/code/runs/test/events.out.tfevents.1605195413.gpu22.cse.cuhk.edu.hk.240470.0 b/DN_RGB/code/runs/test/events.out.tfevents.1605195413.gpu22.cse.cuhk.edu.hk.240470.0 new file mode 100644 index 0000000000000000000000000000000000000000..78eda6cc5f59c86da41a2a013ed065b6ca8804c8 --- /dev/null +++ b/DN_RGB/code/runs/test/events.out.tfevents.1605195413.gpu22.cse.cuhk.edu.hk.240470.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:867ec849fa726cbbf11770d95916d59a596a4262541101fd6e50359e031dde94 +size 40 diff --git a/DN_RGB/code/runs/test/events.out.tfevents.1605196703.gpu22.cse.cuhk.edu.hk.242335.0 b/DN_RGB/code/runs/test/events.out.tfevents.1605196703.gpu22.cse.cuhk.edu.hk.242335.0 new file mode 100644 index 0000000000000000000000000000000000000000..0fcb7d7b6eb0cf3adfec1e86b279bfb6c384da1a --- /dev/null +++ b/DN_RGB/code/runs/test/events.out.tfevents.1605196703.gpu22.cse.cuhk.edu.hk.242335.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:790d08716703c925fbe3942f2b1cb649968e5ddaf594625971f587b57b80da71 +size 40 diff --git a/DN_RGB/code/runs/test/events.out.tfevents.1605250691.gpu48.cse.cuhk.edu.hk.22320.0 b/DN_RGB/code/runs/test/events.out.tfevents.1605250691.gpu48.cse.cuhk.edu.hk.22320.0 new file mode 100644 index 0000000000000000000000000000000000000000..7990f182f758784a7356a382d6648fd8395ae221 --- /dev/null +++ b/DN_RGB/code/runs/test/events.out.tfevents.1605250691.gpu48.cse.cuhk.edu.hk.22320.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1f133cab33d52c09ce835f2958d691d7b629fd437698c9acf0121bacd1bec7e5 +size 40 diff --git a/DN_RGB/code/runs/test/events.out.tfevents.1605253593.gpu48.cse.cuhk.edu.hk.37759.0 b/DN_RGB/code/runs/test/events.out.tfevents.1605253593.gpu48.cse.cuhk.edu.hk.37759.0 new file mode 100644 index 0000000000000000000000000000000000000000..3a9487d2135260a657d2bb2cb60dab64904f5e1e --- /dev/null +++ b/DN_RGB/code/runs/test/events.out.tfevents.1605253593.gpu48.cse.cuhk.edu.hk.37759.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f35dd1f83ebc42b685655abcfcb7699b39e5ebd93cde22b7cecd1f6412ca1dea +size 40 diff --git a/DN_RGB/code/runs/test/events.out.tfevents.1605254191.gpu48.cse.cuhk.edu.hk.1494.0 b/DN_RGB/code/runs/test/events.out.tfevents.1605254191.gpu48.cse.cuhk.edu.hk.1494.0 new file mode 100644 index 0000000000000000000000000000000000000000..3caf197e537e330ec204b452e0010c0b1a257447 --- /dev/null +++ b/DN_RGB/code/runs/test/events.out.tfevents.1605254191.gpu48.cse.cuhk.edu.hk.1494.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7ee16a35cacfb0094d2698ffd3969bf5bd07dd6054c2e762e1089abbc23634a3 +size 40 diff --git a/DN_RGB/code/runs/test/events.out.tfevents.1605254776.gpu48.cse.cuhk.edu.hk.5523.0 b/DN_RGB/code/runs/test/events.out.tfevents.1605254776.gpu48.cse.cuhk.edu.hk.5523.0 new file mode 100644 index 0000000000000000000000000000000000000000..54b155a6522ac21d689eeb0749e878b3f4b711d0 --- /dev/null +++ b/DN_RGB/code/runs/test/events.out.tfevents.1605254776.gpu48.cse.cuhk.edu.hk.5523.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b450d720d59654551ce74712efe0663be7c41dc69cc217f45c970020896ce8d1 +size 40 diff --git a/DN_RGB/code/runs/test/events.out.tfevents.1605281215.gpu6.cse.cuhk.edu.hk.104197.0 b/DN_RGB/code/runs/test/events.out.tfevents.1605281215.gpu6.cse.cuhk.edu.hk.104197.0 new file mode 100644 index 0000000000000000000000000000000000000000..f26c32757a06b68f9bcc30f10df3896c8d764d24 --- /dev/null +++ b/DN_RGB/code/runs/test/events.out.tfevents.1605281215.gpu6.cse.cuhk.edu.hk.104197.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c242cb61c57d5df0c27f5503d36c9f17edc4ffbc7527c8e5d31e9875760a220c +size 40 diff --git a/DN_RGB/code/runs/test/events.out.tfevents.1605281552.gpu6.cse.cuhk.edu.hk.105022.0 b/DN_RGB/code/runs/test/events.out.tfevents.1605281552.gpu6.cse.cuhk.edu.hk.105022.0 new file mode 100644 index 0000000000000000000000000000000000000000..fc51667a904d6cebb724cb9844d315c005d2da53 --- /dev/null +++ b/DN_RGB/code/runs/test/events.out.tfevents.1605281552.gpu6.cse.cuhk.edu.hk.105022.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eab6ad495f86870df8345734d4bbbddb39eca7f4aba314b354e948c4550e272c +size 40 diff --git a/DN_RGB/code/runs/test/events.out.tfevents.1605326269.gpu5.cse.cuhk.edu.hk.81411.0 b/DN_RGB/code/runs/test/events.out.tfevents.1605326269.gpu5.cse.cuhk.edu.hk.81411.0 new file mode 100644 index 0000000000000000000000000000000000000000..02561a4e499792c811194ced92cffd5a84f5d6a4 --- /dev/null +++ b/DN_RGB/code/runs/test/events.out.tfevents.1605326269.gpu5.cse.cuhk.edu.hk.81411.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cfcc12ae650834d14a452888d646436c2b49545530fec00d4a6d2b9506c52c0c +size 40 diff --git a/DN_RGB/code/runs/test/events.out.tfevents.1605326566.gpu5.cse.cuhk.edu.hk.82147.0 b/DN_RGB/code/runs/test/events.out.tfevents.1605326566.gpu5.cse.cuhk.edu.hk.82147.0 new file mode 100644 index 0000000000000000000000000000000000000000..f74e43cd5e975ae43fdebd57876290b4f5fc532e --- /dev/null +++ b/DN_RGB/code/runs/test/events.out.tfevents.1605326566.gpu5.cse.cuhk.edu.hk.82147.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c9b779f4e923fe6f08f392bfc294209de9960f809509fbcf17ab6c230193b422 +size 40 diff --git a/DN_RGB/code/runs/test/events.out.tfevents.1605419594.gpu5.cse.cuhk.edu.hk.236157.0 b/DN_RGB/code/runs/test/events.out.tfevents.1605419594.gpu5.cse.cuhk.edu.hk.236157.0 new file mode 100644 index 0000000000000000000000000000000000000000..b775d17d994d779dfb850953c612e2116f2c4690 --- /dev/null +++ b/DN_RGB/code/runs/test/events.out.tfevents.1605419594.gpu5.cse.cuhk.edu.hk.236157.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:23c6789da483ab65d68b2660b9e276cc97880ce664a47aff0b6ee8f7fbcae26c +size 40 diff --git a/DN_RGB/code/template.py b/DN_RGB/code/template.py new file mode 100644 index 0000000000000000000000000000000000000000..c4842bdaa3e44b3ef51381dad2fe527ac3b5881f --- /dev/null +++ b/DN_RGB/code/template.py @@ -0,0 +1,53 @@ +def set_template(args): + # Set the templates here + if args.template.find('jpeg') >= 0: + args.data_train = 'DIV2K_jpeg' + args.data_test = 'DIV2K_jpeg' + args.epochs = 200 + args.decay = '100' + + if args.template.find('EDSR_paper') >= 0: + args.model = 'EDSR' + args.n_resblocks = 32 + args.n_feats = 256 + args.res_scale = 0.1 + + if args.template.find('MDSR') >= 0: + args.model = 'MDSR' + args.patch_size = 48 + args.epochs = 650 + + if args.template.find('DDBPN') >= 0: + args.model = 'DDBPN' + args.patch_size = 128 + args.scale = '4' + + args.data_test = 'Set5' + + args.batch_size = 20 + args.epochs = 1000 + args.decay = '500' + args.gamma = 0.1 + args.weight_decay = 1e-4 + + args.loss = '1*MSE' + + if args.template.find('GAN') >= 0: + args.epochs = 200 + args.lr = 5e-5 + args.decay = '150' + + if args.template.find('RCAN') >= 0: + args.model = 'RCAN' + args.n_resgroups = 10 + args.n_resblocks = 20 + args.n_feats = 64 + args.chop = True + + if args.template.find('VDSR') >= 0: + args.model = 'VDSR' + args.n_resblocks = 20 + args.n_feats = 64 + args.patch_size = 41 + args.lr = 1e-1 + diff --git a/DN_RGB/code/train-1rec-gpu1-res-n70.sh b/DN_RGB/code/train-1rec-gpu1-res-n70.sh new file mode 100644 index 0000000000000000000000000000000000000000..ace50701b2e6fe669015f6b3cb5ec962924505bf --- /dev/null +++ b/DN_RGB/code/train-1rec-gpu1-res-n70.sh @@ -0,0 +1,24 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +# CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --decay 200-400-600-800 --epoch 1000 --batch_size 16 --n_resblocks 10 --save_models \ +# --model RAFTNETS --scale 1 --patch_size 48 --save RAFTS_DEMOSAIC20_R4 --n_feats 64 --data_train DIV2K --recurrence 4 --data_range "1-800/901-942" + +# python main.py --model LAMBDANET --n_resblocks 20 --recurrence 1 --save_results --n_GPUs 1 --chop --data_test McM+Kodak24+CBSD68+Urban100 --scale 1 \ +# --pre_train ../experiment/LAMBDA_DEMOSAIC20_R1/model/model_best.pt --test_only + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RESNET --scale 70 --patch_size 48 \ +--save RAFTS_RES_N70 --n_feats 64 --data_train DIV2K --recurrence 1 --data_range "1-800/801-805" \ +# --load RAFTS_RES --resume -1 \ No newline at end of file diff --git a/DN_RGB/code/train-1rec-grunet-nobn.sh b/DN_RGB/code/train-1rec-grunet-nobn.sh new file mode 100644 index 0000000000000000000000000000000000000000..314987b949c7be4100bfcdb52327d6120fcfb928 --- /dev/null +++ b/DN_RGB/code/train-1rec-grunet-nobn.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 10 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model GRUNET --scale 50 --patch_size 48 \ +--save GRUNET_N50_R1_nobn --n_feats 64 --data_train DIV2K --recurrence 1 --normalization none \ +# --load GRUNET_N50_R4_nobn --resume -1 diff --git a/DN_RGB/code/train-1rec-raft-s-gpu1-n70.sh b/DN_RGB/code/train-1rec-raft-s-gpu1-n70.sh new file mode 100644 index 0000000000000000000000000000000000000000..42f32a3802f9abb648b3e30359de7217f7e408a6 --- /dev/null +++ b/DN_RGB/code/train-1rec-raft-s-gpu1-n70.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETSINGLE --scale 70 --patch_size 64 \ +--save RAFTSINGLE_N70_R1_nobn --n_feats 64 --data_train DIV2K --recurrence 1 --normalization none \ +# --load RAFTSINGLE_N70_R1_nobn --resume -1 \ No newline at end of file diff --git a/DN_RGB/code/train-1rec-raft-s-gpu1-nobn.sh b/DN_RGB/code/train-1rec-raft-s-gpu1-nobn.sh new file mode 100644 index 0000000000000000000000000000000000000000..9636241669ac2a236ff80e87e9cc0e765359e76c --- /dev/null +++ b/DN_RGB/code/train-1rec-raft-s-gpu1-nobn.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETSINGLE --scale 50 --patch_size 48 \ +--save RAFTSINGLE_N50_R1_nobn --n_feats 64 --data_train DIV2K --recurrence 1 --normalization none \ +--load RAFTSINGLE_N50_R1_nobn --resume -1 \ No newline at end of file diff --git a/DN_RGB/code/train-1rec-raft-s-gpu1-res.sh b/DN_RGB/code/train-1rec-raft-s-gpu1-res.sh new file mode 100644 index 0000000000000000000000000000000000000000..c4079583c3b4665089b4f24393e94f936f8705a3 --- /dev/null +++ b/DN_RGB/code/train-1rec-raft-s-gpu1-res.sh @@ -0,0 +1,24 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +# CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --decay 200-400-600-800 --epoch 1000 --batch_size 16 --n_resblocks 10 --save_models \ +# --model RAFTNETS --scale 1 --patch_size 48 --save RAFTS_DEMOSAIC20_R4 --n_feats 64 --data_train DIV2K --recurrence 4 --data_range "1-800/901-942" + +# python main.py --model LAMBDANET --n_resblocks 20 --recurrence 1 --save_results --n_GPUs 1 --chop --data_test McM+Kodak24+CBSD68+Urban100 --scale 1 \ +# --pre_train ../experiment/LAMBDA_DEMOSAIC20_R1/model/model_best.pt --test_only + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RESNET --scale 50 --patch_size 48 \ +--save RAFTS_RES --n_feats 64 --data_train DIV2K --recurrence 1 \ +--load RAFTS_RES --resume -1 \ No newline at end of file diff --git a/DN_RGB/code/train-1rec-raft-s-gpu1.sh b/DN_RGB/code/train-1rec-raft-s-gpu1.sh new file mode 100644 index 0000000000000000000000000000000000000000..49e14dddba0a6788ef803217c7e7b70c51aaad88 --- /dev/null +++ b/DN_RGB/code/train-1rec-raft-s-gpu1.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETSINGLE --scale 50 --patch_size 48 \ +--save RAFTSINGLE_N50_R1 --n_feats 64 --data_train DIV2K --recurrence 1 \ +--load RAFTSINGLE_N50_R1 --resume -1 \ No newline at end of file diff --git a/DN_RGB/code/train-1rec-raft-s-gpu2-nobn.sh b/DN_RGB/code/train-1rec-raft-s-gpu2-nobn.sh new file mode 100644 index 0000000000000000000000000000000000000000..52fefdbfb22dcd62aa5bcf9c658380eb9f64af65 --- /dev/null +++ b/DN_RGB/code/train-1rec-raft-s-gpu2-nobn.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_nobn --n_feats 64 --data_train DIV2K --recurrence 4 --normalization none \ +--load RAFTS_N50_R4_nobn --resume -1 diff --git a/DN_RGB/code/train-4rec-grunet-gpu1-nobn.sh b/DN_RGB/code/train-4rec-grunet-gpu1-nobn.sh new file mode 100644 index 0000000000000000000000000000000000000000..c1a12d71273bd77117ff32153c9b1444b4c85b4d --- /dev/null +++ b/DN_RGB/code/train-4rec-grunet-gpu1-nobn.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 10 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model GRUNET --scale 50 --patch_size 48 \ +--save GRUNET_N50_R4_nobn --n_feats 64 --data_train DIV2K --recurrence 4 --normalization none \ +# --load GRUNET_N50_R4_nobn --resume -1 diff --git a/DN_RGB/code/train-4rec-raft-s-gpu1-in.sh b/DN_RGB/code/train-4rec-raft-s-gpu1-in.sh new file mode 100644 index 0000000000000000000000000000000000000000..a3c49f53a754446e1bcf005d518463fcf4b644db --- /dev/null +++ b/DN_RGB/code/train-4rec-raft-s-gpu1-in.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_in --n_feats 64 --data_train DIV2K --recurrence 4 --normalization instance \ +--resume -1 --load RAFTS_N50_R4_in \ No newline at end of file diff --git a/DN_RGB/code/train-4rec-raft-s-gpu1-large.sh b/DN_RGB/code/train-4rec-raft-s-gpu1-large.sh new file mode 100644 index 0000000000000000000000000000000000000000..8b982059f751acdba5de4934728f0318421b2d62 --- /dev/null +++ b/DN_RGB/code/train-4rec-raft-s-gpu1-large.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 96 \ +--save RAFTS_N50_R4_bn_large --n_feats 64 --data_train DIV2K --recurrence 4 \ +--load RAFTS_N50_R4_bn_large --resume -1 diff --git a/DN_RGB/code/train-4rec-raft-s-gpu1-ln-gclip.sh b/DN_RGB/code/train-4rec-raft-s-gpu1-ln-gclip.sh new file mode 100644 index 0000000000000000000000000000000000000000..1bbf4e7d1738f3dc8f9217f80d657384de7647bd --- /dev/null +++ b/DN_RGB/code/train-4rec-raft-s-gpu1-ln-gclip.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_ln_clip --n_feats 64 --data_train DIV2K --recurrence 4 --normalization layer --gclip 1.2 \ +--load RAFTS_N50_R4_ln_clip --resume -1 \ No newline at end of file diff --git a/DN_RGB/code/train-4rec-raft-s-gpu1-ln-large.sh b/DN_RGB/code/train-4rec-raft-s-gpu1-ln-large.sh new file mode 100644 index 0000000000000000000000000000000000000000..389523c097b7a3d085b0c3a9646973c1b2093e82 --- /dev/null +++ b/DN_RGB/code/train-4rec-raft-s-gpu1-ln-large.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 96 --reset \ +--save RAFTS_N50_R4_ln_large --n_feats 64 --data_train DIV2K --recurrence 4 --normalization layer \ No newline at end of file diff --git a/DN_RGB/code/train-4rec-raft-s-gpu1-ln-res10.sh b/DN_RGB/code/train-4rec-raft-s-gpu1-ln-res10.sh new file mode 100644 index 0000000000000000000000000000000000000000..68525a45585ae978e0a41434eaa6a76c806c5be3 --- /dev/null +++ b/DN_RGB/code/train-4rec-raft-s-gpu1-ln-res10.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 10 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 --reset \ +--save RAFTS_N50_R4_ln_res10 --n_feats 64 --data_train DIV2K --recurrence 4 --normalization layer \ No newline at end of file diff --git a/DN_RGB/code/train-4rec-raft-s-gpu1-ln-small.sh b/DN_RGB/code/train-4rec-raft-s-gpu1-ln-small.sh new file mode 100644 index 0000000000000000000000000000000000000000..bb0b15de0a6397a37e8d6537903e12373e6eab65 --- /dev/null +++ b/DN_RGB/code/train-4rec-raft-s-gpu1-ln-small.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 64 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 24 --reset \ +--save RAFTS_N50_R4_ln_small --n_feats 64 --data_train DIV2K --recurrence 4 --normalization layer --gclip 1.2 \ No newline at end of file diff --git a/DN_RGB/code/train-4rec-raft-s-gpu1-ln.sh b/DN_RGB/code/train-4rec-raft-s-gpu1-ln.sh new file mode 100644 index 0000000000000000000000000000000000000000..518ea3e31aaff05012c6471ea8deada43c9c6f00 --- /dev/null +++ b/DN_RGB/code/train-4rec-raft-s-gpu1-ln.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 --reset \ +--save RAFTS_N50_R4_ln --n_feats 64 --data_train DIV2K --recurrence 4 --normalization layer \ No newline at end of file diff --git a/DN_RGB/code/train-4rec-raft-s-gpu1-nobn-nores.sh b/DN_RGB/code/train-4rec-raft-s-gpu1-nobn-nores.sh new file mode 100644 index 0000000000000000000000000000000000000000..8d7fa627219070929531644f76ce936a79346838 --- /dev/null +++ b/DN_RGB/code/train-4rec-raft-s-gpu1-nobn-nores.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETSNORES --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_nobn_nores --n_feats 64 --data_train DIV2K --recurrence 4 --normalization none --detach \ +--load RAFTS_N50_R4_nobn_nores --resume -1 diff --git a/DN_RGB/code/train-4rec-raft-s-gpu1-nobn-re.sh b/DN_RGB/code/train-4rec-raft-s-gpu1-nobn-re.sh new file mode 100644 index 0000000000000000000000000000000000000000..abd1cc29cd8af237cf4d52ced7fa4327f2b18c35 --- /dev/null +++ b/DN_RGB/code/train-4rec-raft-s-gpu1-nobn-re.sh @@ -0,0 +1,19 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_nobn_re --n_feats 64 --data_train DIV2K --recurrence 4 --normalization none \ +--pre_train ../experiment/RAFTS_N50_R4_nobn/model/model_best.pt +# --load RAFTS_N50_R4_nobn --resume -1 diff --git a/DN_RGB/code/train-4rec-raft-s-gpu1-nobn-res10.sh b/DN_RGB/code/train-4rec-raft-s-gpu1-nobn-res10.sh new file mode 100644 index 0000000000000000000000000000000000000000..4249b09b8daf90fcb053c24959981c629e7bf725 --- /dev/null +++ b/DN_RGB/code/train-4rec-raft-s-gpu1-nobn-res10.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 10 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_nobn_res10 --n_feats 64 --data_train DIV2K --recurrence 4 --normalization none \ +--load RAFTS_N50_R4_nobn_res10 --resume -1 \ No newline at end of file diff --git a/DN_RGB/code/train-4rec-raft-s-gpu1-nobn.sh b/DN_RGB/code/train-4rec-raft-s-gpu1-nobn.sh new file mode 100644 index 0000000000000000000000000000000000000000..52fefdbfb22dcd62aa5bcf9c658380eb9f64af65 --- /dev/null +++ b/DN_RGB/code/train-4rec-raft-s-gpu1-nobn.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_nobn --n_feats 64 --data_train DIV2K --recurrence 4 --normalization none \ +--load RAFTS_N50_R4_nobn --resume -1 diff --git a/DN_RGB/code/train-4rec-raft-s-gpu1-r3.sh b/DN_RGB/code/train-4rec-raft-s-gpu1-r3.sh new file mode 100644 index 0000000000000000000000000000000000000000..c4ce98cec1575bf865be094d8703847d023eed15 --- /dev/null +++ b/DN_RGB/code/train-4rec-raft-s-gpu1-r3.sh @@ -0,0 +1,19 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 \ +--save RAFTS_N50_R3_layer_r3 --n_feats 64 --data_train DIV2K --recurrence 3 --normalization layer \ +--lamradius 3 --gclip 1.0 \ +# --load RAFTS_N50_R3_layer_r3 --resume -1 diff --git a/DN_RGB/code/train-4rec-raft-s-gpu1-r7-detach-lamres.sh b/DN_RGB/code/train-4rec-raft-s-gpu1-r7-detach-lamres.sh new file mode 100644 index 0000000000000000000000000000000000000000..3c6ffe2f21ba00e607d6d81aaba3bc7a97e2fca7 --- /dev/null +++ b/DN_RGB/code/train-4rec-raft-s-gpu1-r7-detach-lamres.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETSRES --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_nobn_r7_detach_res --n_feats 64 --data_train DIV2K --recurrence 4 --normalization none \ +--lamradius 7 --detach --load RAFTS_N50_R4_nobn_r7_detach_res --resume -1 diff --git a/DN_RGB/code/train-4rec-raft-s-gpu1-r7-detach.sh b/DN_RGB/code/train-4rec-raft-s-gpu1-r7-detach.sh new file mode 100644 index 0000000000000000000000000000000000000000..b0c3adb06f53849babb7fb8a13a1e97efa892634 --- /dev/null +++ b/DN_RGB/code/train-4rec-raft-s-gpu1-r7-detach.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_nobn_r7_detach --n_feats 64 --data_train DIV2K --recurrence 4 --normalization none \ +--lamradius 7 --detach --load RAFTS_N50_R4_nobn_r7_detach --resume -1 diff --git a/DN_RGB/code/train-4rec-raft-s-gpu1-r7.sh b/DN_RGB/code/train-4rec-raft-s-gpu1-r7.sh new file mode 100644 index 0000000000000000000000000000000000000000..c91099eaf1b6c2e245e6efe278d4ec87665e4010 --- /dev/null +++ b/DN_RGB/code/train-4rec-raft-s-gpu1-r7.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_nobn_r7 --n_feats 64 --data_train DIV2K --recurrence 4 --normalization none \ +--lamradius 7 --load RAFTS_N50_R4_nobn_r7 --resume -1 diff --git a/DN_RGB/code/train-4rec-raft-s-gpu1-small.sh b/DN_RGB/code/train-4rec-raft-s-gpu1-small.sh new file mode 100644 index 0000000000000000000000000000000000000000..87e3da9f10f308b418e0722ba997a100d64d51ff --- /dev/null +++ b/DN_RGB/code/train-4rec-raft-s-gpu1-small.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 24 --reset \ +--save RAFTS_N50_R4_bn_small --n_feats 64 --data_train DIV2K --recurrence 4 \ No newline at end of file diff --git a/DN_RGB/code/train-4rec-raft-s-gpu1.sh b/DN_RGB/code/train-4rec-raft-s-gpu1.sh new file mode 100644 index 0000000000000000000000000000000000000000..df6e9559aebcae88fdfaa07bbaacb8f2552a3278 --- /dev/null +++ b/DN_RGB/code/train-4rec-raft-s-gpu1.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_bn --n_feats 64 --data_train DIV2K --recurrence 4 \ +--load RAFTS_N50_R4_bn --resume -1 diff --git a/DN_RGB/code/train-4rec-raft-s-gpu2-nobn-res40.sh b/DN_RGB/code/train-4rec-raft-s-gpu2-nobn-res40.sh new file mode 100644 index 0000000000000000000000000000000000000000..a1180b289685df15fc90ccde22ae0919a25b28a2 --- /dev/null +++ b/DN_RGB/code/train-4rec-raft-s-gpu2-nobn-res40.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=1,2 python main.py --n_GPUs 2 --lr 1e-4 --batch_size 16 --n_resblocks 40 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_nobn_res40 --n_feats 64 --data_train DIV2K --recurrence 4 --normalization none \ +--gclip 1.5 --amp # --load RAFTS_N50_R4_nobn --resume -1 diff --git a/DN_RGB/code/train-4rec-raft-s-gpu2-nobn-res8.sh b/DN_RGB/code/train-4rec-raft-s-gpu2-nobn-res8.sh new file mode 100644 index 0000000000000000000000000000000000000000..e54e25102c968329125addeba76fb4a4900506e3 --- /dev/null +++ b/DN_RGB/code/train-4rec-raft-s-gpu2-nobn-res8.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=1,2 python main.py --n_GPUs 2 --lr 1e-4 --batch_size 16 --n_resblocks 8 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 \ +--save RAFTS_N50_R8_nobn_res8 --n_feats 64 --data_train DIV2K --recurrence 8 --normalization none \ +# --load RAFTS_N50_R8_nobn_res8 --resume -1 diff --git a/DN_RGB/code/train-4rec-raft-s-gpu2-nobn.sh b/DN_RGB/code/train-4rec-raft-s-gpu2-nobn.sh new file mode 100644 index 0000000000000000000000000000000000000000..d08ef00085f16dd5ae06ff6955a95f7619720050 --- /dev/null +++ b/DN_RGB/code/train-4rec-raft-s-gpu2-nobn.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=0,3 python main.py --n_GPUs 2 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_nobn --n_feats 64 --data_train DIV2K --recurrence 4 --normalization none \ +--load RAFTS_N50_R4_nobn --resume -1 diff --git a/DN_RGB/code/train-6rec-rafts-s-gpu1-r3-detach.sh b/DN_RGB/code/train-6rec-rafts-s-gpu1-r3-detach.sh new file mode 100644 index 0000000000000000000000000000000000000000..79192a113e60466c848565d56bd4c255cb606a71 --- /dev/null +++ b/DN_RGB/code/train-6rec-rafts-s-gpu1-r3-detach.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-4 --batch_size 16 --n_resblocks 20 --save_models \ +--epoch 1000 --decay 200-400-600-800 --model RAFTNETS --scale 50 --patch_size 48 \ +--save RAFTS_N50_R4_nobn_r3_detach0.6 --n_feats 64 --data_train DIV2K --recurrence 6 --normalization none \ +--lamradius 3 --detach --decay_gamma 0.6 # --load RAFTS_N50_R4_nobn --resume -1 diff --git a/DN_RGB/code/train-l.sh b/DN_RGB/code/train-l.sh new file mode 100644 index 0000000000000000000000000000000000000000..2ca16c6232b2f5af32451704653fca2d783721f5 --- /dev/null +++ b/DN_RGB/code/train-l.sh @@ -0,0 +1,4 @@ +#!/bin/bash +bash ./prepare.sh +CUDA_VISIBLE_DEVICES=1 python main.py --n_GPUs 1 --lr 1e-5 --batch_size 16 --save_models --epoch 100 --model LAMBDANET \ +--scale 50 --patch_size 128 --reset --save MDSR_lambda_N50 --n_feats 64 --data_train DIV2K --dir_data="/data/ssd/public/liuhy/sr/dataset" diff --git a/DN_RGB/code/train-lr.sh b/DN_RGB/code/train-lr.sh new file mode 100644 index 0000000000000000000000000000000000000000..d1e35b115a343133541626be41de0358dfc2bdaf --- /dev/null +++ b/DN_RGB/code/train-lr.sh @@ -0,0 +1,4 @@ +#!/bin/bash +bash ./prepare.sh +CUDA_VISIBLE_DEVICES=2 python main.py --n_GPUs 1 --lr 1e-5 --batch_size 16 --save_models --epoch 100 --model PANET \ +--scale 50 --patch_size 48 --reset --save MDSR_att_N50 --n_feats 64 --data_train DIV2K --dir_data="/data/ssd/public/liuhy/sr/dataset" diff --git a/DN_RGB/code/train-rafts-tanh.sh b/DN_RGB/code/train-rafts-tanh.sh new file mode 100644 index 0000000000000000000000000000000000000000..c6e5d9939139330caab99338dc2155717f9f5579 --- /dev/null +++ b/DN_RGB/code/train-rafts-tanh.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +bash ./prepare.sh + +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-5 --batch_size 16 --save_models --epoch 100 \ +--model RAFTNETSTANH --scale 50 --patch_size 48 --reset --save RAFTS_TANH_N50 --n_feats 64 --data_train DIV2K \ +--n_resblocks 12 --recurrence 3 \ No newline at end of file diff --git a/DN_RGB/code/train-rafts.sh b/DN_RGB/code/train-rafts.sh new file mode 100644 index 0000000000000000000000000000000000000000..ebf73878e6af33597bbc80e7c2076c7430c5545c --- /dev/null +++ b/DN_RGB/code/train-rafts.sh @@ -0,0 +1,21 @@ +#!/bin/bash + +bash ./prepare.sh + +lst=0 +for i in {0..3}; +do + if nvidia-smi -i $i | grep -q "python"; then + : + else + lst=$i + break + fi +done +#python main.py --n_GPUs 1 --lr 1e-5 --batch_size 16 --save_models --epoch 100 --model PANET --scale 50 --patch_size 48 +# --reset --save MDSR_att_N50 --n_feats 64 --data_train DIV2K --chop + + +CUDA_VISIBLE_DEVICES=$lst python main.py --n_GPUs 1 --lr 1e-5 --batch_size 16 --save_models --epoch 100 \ +--model RAFTNETS --scale 50 --patch_size 48 --reset --save RAFTS_N50 --n_feats 64 --data_train DIV2K \ +--n_resblocks 12 --recurrence 3 \ No newline at end of file diff --git a/DN_RGB/code/train.sh b/DN_RGB/code/train.sh new file mode 100644 index 0000000000000000000000000000000000000000..e09d33088512568d843804f6bd7eb17619dcb4a3 --- /dev/null +++ b/DN_RGB/code/train.sh @@ -0,0 +1,4 @@ +#!/bin/bash +bash ./prepare.sh +CUDA_VISIBLE_DEVICES=0 python main.py --n_GPUs 1 --lr 1e-5 --batch_size 16 --save_models --epoch 100 --model PANET \ +--scale 50 --patch_size 48 --reset --save MDSR_att_N50 --n_feats 64 --data_train DIV2K --chop --dir_data="/data/ssd/public/liuhy/sr/dataset" diff --git a/DN_RGB/code/trainer.py b/DN_RGB/code/trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..8c581f96260cdbc39324e32593fb216577f48a22 --- /dev/null +++ b/DN_RGB/code/trainer.py @@ -0,0 +1,182 @@ +import os +import math +from decimal import Decimal + +import utility + +import torch +import torch.nn.utils as utils +from tqdm import tqdm + +import torch.cuda.amp as amp + +from torch.utils.tensorboard import SummaryWriter +import torchvision + +import numpy as np + +class Trainer(): + def __init__(self, args, loader, my_model, my_loss, ckp): + self.args = args + self.scale = args.scale + + self.ckp = ckp + self.loader_train = loader.loader_train + self.loader_test = loader.loader_test + self.model = my_model + self.loss = my_loss + self.optimizer = utility.make_optimizer(args, self.model) + + if self.args.load != '': + self.optimizer.load(ckp.dir, epoch=len(ckp.log)) + + self.error_last = 1e8 + self.scaler=amp.GradScaler( + enabled=args.amp + ) + self.writter=None + self.recurrence=args.recurrence + if args.recurrence>1: + self.writter=SummaryWriter(f"runs/{args.save}") + + def train(self): + self.loss.step() + epoch = self.optimizer.get_last_epoch() + 1 + lr = self.optimizer.get_lr() + + self.ckp.write_log( + '[Epoch {}]\tLearning rate: {:.2e}'.format(epoch, Decimal(lr)) + ) + self.loss.start_log() + self.model.train() + + timer_data, timer_model = utility.timer(), utility.timer() + # TEMP + self.loader_train.dataset.set_scale(0) + total=len(self.loader_train) + buffer=[0.0]*self.recurrence + # torch.autograd.set_detect_anomaly(True) + for batch, (lr, hr, _,) in enumerate(self.loader_train): + lr, hr = self.prepare(lr, hr) + # print(lr.min(),lr.max(), hr.min(),hr.max()) + # exit(0) + timer_data.hold() + timer_model.tic() + + self.optimizer.zero_grad() + with amp.autocast(self.args.amp): + sr = self.model(lr, 0) + if len(sr)==1: + sr=sr[0] + # loss,buffer_lst=sequence_loss(sr,hr) + loss = self.loss(sr, hr) + self.scaler.scale(loss).backward() + if self.args.gclip > 0: + self.scaler.unscale_(self.optimizer) + utils.clip_grad_value_( + self.model.parameters(), + self.args.gclip + ) + self.scaler.step(self.optimizer) + self.scaler.update() + for i in range(self.recurrence): + buffer[i]+=self.loss.buffer[i] + # self.optimizer.step() + + timer_model.hold() + + if (batch + 1) % self.args.print_every == 0: + self.ckp.write_log('[{}/{}]\t{}\t{:.1f}+{:.1f}s'.format( + (batch + 1) * self.args.batch_size, + len(self.loader_train.dataset), + self.loss.display_loss(batch), + timer_model.release(), + timer_data.release())) + + timer_data.tic() + if self.writter: + for i in range(self.recurrence): + grid=torchvision.utils.make_grid(sr[i]) + self.writter.add_image(f"Output{i}",grid,epoch) + self.writter.add_scalar(f"Loss{i}",buffer[i]/total,epoch) + self.writter.add_image("Input",torchvision.utils.make_grid(lr),epoch) + self.writter.add_image("Target",torchvision.utils.make_grid(hr),epoch) + self.loss.end_log(len(self.loader_train)) + self.error_last = self.loss.log[-1, -1] + self.optimizer.schedule() + + def test(self): + torch.set_grad_enabled(False) + + epoch = self.optimizer.get_last_epoch() + self.ckp.write_log('\nEvaluation:') + self.ckp.add_log( + torch.zeros(1, len(self.loader_test), len(self.scale)) + ) + self.model.eval() + + timer_test = utility.timer() + if self.args.save_results: self.ckp.begin_background() + for idx_data, d in enumerate(self.loader_test): + for idx_scale, scale in enumerate(self.scale): + d.dataset.set_scale(idx_scale) + for lr, hr, filename in tqdm(d, ncols=80): + lr, hr = self.prepare(lr, hr) + with amp.autocast(self.args.amp): + sr = self.model(lr, idx_scale) + if isinstance(sr,list): + sr=sr[-1] + sr = utility.quantize(sr, self.args.rgb_range) + + save_list = [sr] + self.ckp.log[-1, idx_data, idx_scale] += utility.calc_psnr( + sr, hr, scale, self.args.rgb_range, dataset=d + ) + if self.args.save_gt: + save_list.extend([lr, hr]) + + if self.args.save_results: + self.ckp.save_results(d, filename[0], save_list, scale) + + self.ckp.log[-1, idx_data, idx_scale] /= len(d) + best = self.ckp.log.max(0) + self.ckp.write_log( + '[{} x{}]\tPSNR: {:.3f} (Best: {:.3f} @epoch {})'.format( + d.dataset.name, + scale, + self.ckp.log[-1, idx_data, idx_scale], + best[0][idx_data, idx_scale], + best[1][idx_data, idx_scale] + 1 + ) + ) + self.ckp.write_log('Forward: {:.2f}s\n'.format(timer_test.toc())) + self.ckp.write_log('Saving...') + # torch.cuda.empty_cache() + if self.args.save_results: + self.ckp.end_background() + + if not self.args.test_only: + self.ckp.save(self, epoch, is_best=(best[1][0, 0] + 1 == epoch)) + + self.ckp.write_log( + 'Total: {:.2f}s\n'.format(timer_test.toc()), refresh=True + ) + + torch.set_grad_enabled(True) + + def prepare(self, *args): + device = torch.device('cpu' if self.args.cpu else 'cuda') + def _prepare(tensor): + if self.args.precision == 'half': tensor = tensor.half() + return tensor.to(device) + + return [_prepare(a) for a in args] + + def terminate(self): + if self.args.test_only: + self.test() + return True + else: + epoch = self.optimizer.get_last_epoch() + 1 + return epoch >= self.args.epochs + diff --git a/DN_RGB/code/utility.py b/DN_RGB/code/utility.py new file mode 100644 index 0000000000000000000000000000000000000000..390bdc37251d636ac965960bd2b5a63402e922e1 --- /dev/null +++ b/DN_RGB/code/utility.py @@ -0,0 +1,242 @@ +import os +import math +import time +import datetime +from multiprocessing import Process +from multiprocessing import Queue + +import matplotlib +matplotlib.use('Agg') +import matplotlib.pyplot as plt + +import numpy as np +import imageio + +import torch +import torch.optim as optim +import torch.optim.lr_scheduler as lrs + +class timer(): + def __init__(self): + self.acc = 0 + self.tic() + + def tic(self): + self.t0 = time.time() + + def toc(self, restart=False): + diff = time.time() - self.t0 + if restart: self.t0 = time.time() + return diff + + def hold(self): + self.acc += self.toc() + + def release(self): + ret = self.acc + self.acc = 0 + + return ret + + def reset(self): + self.acc = 0 + +class checkpoint(): + def __init__(self, args): + self.args = args + self.ok = True + self.log = torch.Tensor() + now = datetime.datetime.now().strftime('%Y-%m-%d-%H:%M:%S') + + if not args.load: + if not args.save: + args.save = now + self.dir = os.path.join('..', 'experiment', args.save) + else: + self.dir = os.path.join('..', 'experiment', args.load) + if os.path.exists(self.dir): + self.log = torch.load(self.get_path('psnr_log.pt')) + print('Continue from epoch {}...'.format(len(self.log))) + else: + args.load = '' + + if args.reset: + os.system('rm -rf ' + self.dir) + args.load = '' + + os.makedirs(self.dir, exist_ok=True) + os.makedirs(self.get_path('model'), exist_ok=True) + for d in args.data_test: + os.makedirs(self.get_path('results-{}'.format(d)), exist_ok=True) + + open_type = 'a' if os.path.exists(self.get_path('log.txt'))else 'w' + self.log_file = open(self.get_path('log.txt'), open_type) + with open(self.get_path('config.txt'), open_type) as f: + f.write(now + '\n\n') + for arg in vars(args): + f.write('{}: {}\n'.format(arg, getattr(args, arg))) + f.write('\n') + + self.n_processes = 8 + + def get_path(self, *subdir): + return os.path.join(self.dir, *subdir) + + def save(self, trainer, epoch, is_best=False): + trainer.model.save(self.get_path('model'), epoch, is_best=is_best) + trainer.loss.save(self.dir) + trainer.loss.plot_loss(self.dir, epoch) + + self.plot_psnr(epoch) + trainer.optimizer.save(self.dir) + torch.save(self.log, self.get_path('psnr_log.pt')) + + def add_log(self, log): + self.log = torch.cat([self.log, log]) + + def write_log(self, log, refresh=False): + print(log) + self.log_file.write(log + '\n') + if refresh: + self.log_file.close() + self.log_file = open(self.get_path('log.txt'), 'a') + + def done(self): + self.log_file.close() + + def plot_psnr(self, epoch): + axis = np.linspace(1, epoch, epoch) + for idx_data, d in enumerate(self.args.data_test): + label = 'SR on {}'.format(d) + fig = plt.figure() + plt.title(label) + for idx_scale, scale in enumerate(self.args.scale): + plt.plot( + axis, + self.log[:, idx_data, idx_scale].numpy(), + label='Scale {}'.format(scale) + ) + plt.legend() + plt.xlabel('Epochs') + plt.ylabel('PSNR') + plt.grid(True) + plt.savefig(self.get_path('test_{}.pdf'.format(d))) + plt.close(fig) + + def begin_background(self): + self.queue = Queue() + + def bg_target(queue): + while True: + if not queue.empty(): + filename, tensor = queue.get() + if filename is None: break + imageio.imwrite(filename, tensor.numpy()) + + self.process = [ + Process(target=bg_target, args=(self.queue,)) \ + for _ in range(self.n_processes) + ] + + for p in self.process: p.start() + + def end_background(self): + for _ in range(self.n_processes): self.queue.put((None, None)) + while not self.queue.empty(): time.sleep(1) + for p in self.process: p.join() + + def save_results(self, dataset, filename, save_list, scale): + if self.args.save_results: + filename = self.get_path( + 'results-{}'.format(dataset.dataset.name), + '{}_x{}_'.format(filename, scale) + ) + + postfix = ('DN', 'LQ', 'HQ') + for v, p in zip(save_list, postfix): + normalized = v[0].mul(255 / self.args.rgb_range) + tensor_cpu = normalized.byte().permute(1, 2, 0).cpu() + self.queue.put(('{}{}.png'.format(filename, p), tensor_cpu)) + +def quantize(img, rgb_range): + pixel_range = 255 / rgb_range + return img.mul(pixel_range).clamp(0, 255).round().div(pixel_range) + +def calc_psnr(sr, hr, scale, rgb_range, dataset=None): + if hr.nelement() == 1: return 0 + + diff = (sr - hr) / rgb_range + if dataset and dataset.dataset.benchmark: + shave = scale + if diff.size(1) > 5: + gray_coeffs = [65.738, 129.057, 25.064] + convert = diff.new_tensor(gray_coeffs).view(1, 3, 1, 1) / 256 + diff = diff.mul(convert).sum(dim=1) + else: + shave = scale + 6 + + valid = diff[..., :, :] + mse = valid.pow(2).mean() + + return -10 * math.log10(mse) + +def make_optimizer(args, target): + ''' + make optimizer and scheduler together + ''' + # optimizer + trainable = filter(lambda x: x.requires_grad, target.parameters()) + kwargs_optimizer = {'lr': args.lr, 'weight_decay': args.weight_decay} + + if args.optimizer == 'SGD': + optimizer_class = optim.SGD + kwargs_optimizer['momentum'] = args.momentum + elif args.optimizer == 'ADAM': + optimizer_class = optim.Adam + kwargs_optimizer['betas'] = args.betas + kwargs_optimizer['eps'] = args.epsilon + elif args.optimizer == 'ADAMW': + optimizer_class = optim.AdamW + kwargs_optimizer['betas'] = args.betas + kwargs_optimizer['eps'] = args.epsilon + kwargs_optimizer["weight_decay"]=0.01 + elif args.optimizer == 'RMSprop': + optimizer_class = optim.RMSprop + kwargs_optimizer['eps'] = args.epsilon + + # scheduler + milestones = list(map(lambda x: int(x), args.decay.split('-'))) + kwargs_scheduler = {'milestones': milestones, 'gamma': args.gamma} + scheduler_class = lrs.MultiStepLR + + class CustomOptimizer(optimizer_class): + def __init__(self, *args, **kwargs): + super(CustomOptimizer, self).__init__(*args, **kwargs) + + def _register_scheduler(self, scheduler_class, **kwargs): + self.scheduler = scheduler_class(self, **kwargs) + + def save(self, save_dir): + torch.save(self.state_dict(), self.get_dir(save_dir)) + + def load(self, load_dir, epoch=1): + self.load_state_dict(torch.load(self.get_dir(load_dir))) + if epoch > 1: + for _ in range(epoch): self.scheduler.step() + + def get_dir(self, dir_path): + return os.path.join(dir_path, 'optimizer.pt') + + def schedule(self): + self.scheduler.step() + + def get_lr(self): + return self.scheduler.get_lr()[0] + + def get_last_epoch(self): + return self.scheduler.last_epoch + + optimizer = CustomOptimizer(trainable, **kwargs_optimizer) + optimizer._register_scheduler(scheduler_class, **kwargs_scheduler) + return optimizer + diff --git a/DN_RGB/code/utils/__init__.py b/DN_RGB/code/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/DN_RGB/code/utils/__pycache__/__init__.cpython-35.pyc b/DN_RGB/code/utils/__pycache__/__init__.cpython-35.pyc new file mode 100644 index 0000000000000000000000000000000000000000..40f387d415e1f4bb9bf4ceac0a889a9aebc334be Binary files /dev/null and b/DN_RGB/code/utils/__pycache__/__init__.cpython-35.pyc differ diff --git a/DN_RGB/code/utils/__pycache__/__init__.cpython-36.pyc b/DN_RGB/code/utils/__pycache__/__init__.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..10faeb4332adc79696bf265c77d80df7f0ff8bf2 Binary files /dev/null and b/DN_RGB/code/utils/__pycache__/__init__.cpython-36.pyc differ diff --git a/DN_RGB/code/utils/__pycache__/__init__.cpython-37.pyc b/DN_RGB/code/utils/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b629363fd5314b39b28610097e114744b6fbc8f8 Binary files /dev/null and b/DN_RGB/code/utils/__pycache__/__init__.cpython-37.pyc differ diff --git a/DN_RGB/code/utils/__pycache__/tools.cpython-35.pyc b/DN_RGB/code/utils/__pycache__/tools.cpython-35.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a91ca012e6881f1c14b197e62e83607d0e56de35 Binary files /dev/null and b/DN_RGB/code/utils/__pycache__/tools.cpython-35.pyc differ diff --git a/DN_RGB/code/utils/__pycache__/tools.cpython-36.pyc b/DN_RGB/code/utils/__pycache__/tools.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..197978b49e9c82d2b0f4969417769f1a26229bc6 Binary files /dev/null and b/DN_RGB/code/utils/__pycache__/tools.cpython-36.pyc differ diff --git a/DN_RGB/code/utils/__pycache__/tools.cpython-37.pyc b/DN_RGB/code/utils/__pycache__/tools.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..926a91ec949be86cd1ea655d03be552013e2a6a9 Binary files /dev/null and b/DN_RGB/code/utils/__pycache__/tools.cpython-37.pyc differ diff --git a/DN_RGB/code/utils/tools.py b/DN_RGB/code/utils/tools.py new file mode 100644 index 0000000000000000000000000000000000000000..c40cd8dc5e95d353254b950c9ec373126c5fe63e --- /dev/null +++ b/DN_RGB/code/utils/tools.py @@ -0,0 +1,81 @@ +import os +import torch +import numpy as np +from PIL import Image + +import torch.nn.functional as F + +def normalize(x): + return x.mul_(2).add_(-1) + +def same_padding(images, ksizes, strides, rates): + assert len(images.size()) == 4 + batch_size, channel, rows, cols = images.size() + out_rows = (rows + strides[0] - 1) // strides[0] + out_cols = (cols + strides[1] - 1) // strides[1] + effective_k_row = (ksizes[0] - 1) * rates[0] + 1 + effective_k_col = (ksizes[1] - 1) * rates[1] + 1 + padding_rows = max(0, (out_rows-1)*strides[0]+effective_k_row-rows) + padding_cols = max(0, (out_cols-1)*strides[1]+effective_k_col-cols) + # Pad the input + padding_top = int(padding_rows / 2.) + padding_left = int(padding_cols / 2.) + padding_bottom = padding_rows - padding_top + padding_right = padding_cols - padding_left + paddings = (padding_left, padding_right, padding_top, padding_bottom) + images = torch.nn.ZeroPad2d(paddings)(images) + return images + + +def extract_image_patches(images, ksizes, strides, rates, padding='same'): + """ + Extract patches from images and put them in the C output dimension. + :param padding: + :param images: [batch, channels, in_rows, in_cols]. A 4-D Tensor with shape + :param ksizes: [ksize_rows, ksize_cols]. The size of the sliding window for + each dimension of images + :param strides: [stride_rows, stride_cols] + :param rates: [dilation_rows, dilation_cols] + :return: A Tensor + """ + assert len(images.size()) == 4 + assert padding in ['same', 'valid'] + batch_size, channel, height, width = images.size() + + if padding == 'same': + images = same_padding(images, ksizes, strides, rates) + elif padding == 'valid': + pass + else: + raise NotImplementedError('Unsupported padding type: {}.\ + Only "same" or "valid" are supported.'.format(padding)) + + unfold = torch.nn.Unfold(kernel_size=ksizes, + dilation=rates, + padding=0, + stride=strides) + patches = unfold(images) + return patches # [N, C*k*k, L], L is the total number of such blocks +def reduce_mean(x, axis=None, keepdim=False): + if not axis: + axis = range(len(x.shape)) + for i in sorted(axis, reverse=True): + x = torch.mean(x, dim=i, keepdim=keepdim) + return x + + +def reduce_std(x, axis=None, keepdim=False): + if not axis: + axis = range(len(x.shape)) + for i in sorted(axis, reverse=True): + x = torch.std(x, dim=i, keepdim=keepdim) + return x + + +def reduce_sum(x, axis=None, keepdim=False): + if not axis: + axis = range(len(x.shape)) + for i in sorted(axis, reverse=True): + x = torch.sum(x, dim=i, keepdim=keepdim) + return x + diff --git a/DN_RGB/code/videotester.py b/DN_RGB/code/videotester.py new file mode 100644 index 0000000000000000000000000000000000000000..4e4f3581a8d7318208a1f7bd3b8eae11bfc13aa4 --- /dev/null +++ b/DN_RGB/code/videotester.py @@ -0,0 +1,72 @@ +import os +import math + +import utility +from data import common + +import torch +import cv2 + +from tqdm import tqdm + +class VideoTester(): + def __init__(self, args, my_model, ckp): + self.args = args + self.scale = args.scale + + self.ckp = ckp + self.model = my_model + + self.filename, _ = os.path.splitext(os.path.basename(args.dir_demo)) + + def test(self): + torch.set_grad_enabled(False) + + self.ckp.write_log('\nEvaluation on video:') + self.model.eval() + + timer_test = utility.timer() + for idx_scale, scale in enumerate(self.scale): + vidcap = cv2.VideoCapture(self.args.dir_demo) + total_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT)) + vidwri = cv2.VideoWriter( + self.ckp.get_path('{}_x{}.avi'.format(self.filename, scale)), + cv2.VideoWriter_fourcc(*'XVID'), + vidcap.get(cv2.CAP_PROP_FPS), + ( + int(scale * vidcap.get(cv2.CAP_PROP_FRAME_WIDTH)), + int(scale * vidcap.get(cv2.CAP_PROP_FRAME_HEIGHT)) + ) + ) + + tqdm_test = tqdm(range(total_frames), ncols=80) + for _ in tqdm_test: + success, lr = vidcap.read() + if not success: break + + lr, = common.set_channel(lr, n_channels=self.args.n_colors) + lr, = common.np2Tensor(lr, rgb_range=self.args.rgb_range) + lr, = self.prepare(lr.unsqueeze(0)) + sr = self.model(lr, idx_scale) + sr = utility.quantize(sr, self.args.rgb_range).squeeze(0) + + normalized = sr * 255 / self.args.rgb_range + ndarr = normalized.byte().permute(1, 2, 0).cpu().numpy() + vidwri.write(ndarr) + + vidcap.release() + vidwri.release() + + self.ckp.write_log( + 'Total: {:.2f}s\n'.format(timer_test.toc()), refresh=True + ) + torch.set_grad_enabled(True) + + def prepare(self, *args): + device = torch.device('cpu' if self.args.cpu else 'cuda') + def _prepare(tensor): + if self.args.precision == 'half': tensor = tensor.half() + return tensor.to(device) + + return [_prepare(a) for a in args] + diff --git a/DN_RGB/experiment/PP_Evaluate_DN_RGB_PSNR_SSIM.m b/DN_RGB/experiment/PP_Evaluate_DN_RGB_PSNR_SSIM.m new file mode 100644 index 0000000000000000000000000000000000000000..93326edd4a26122e2bbce99f3be1bad61f6059cf --- /dev/null +++ b/DN_RGB/experiment/PP_Evaluate_DN_RGB_PSNR_SSIM.m @@ -0,0 +1,286 @@ +function PP_Evaluate_DN_RGB_PSNR_SSIM() +clear all; close all; clc +tic +%% set path +path_HR = 'HQ'; +methods = {'Test_RNAN'}; +method_name = 'RNAN'; % indicates the name in the file +sigma_current = 10; +dataset = {'Kodak24', 'CBSD68', 'Urban100'}; + +ext = {'*.jpg', '*.png', '*.bmp'}; +num_method = length(methods); +num_set = length(dataset); + +for idx_method = 1:num_method + + for idx_set = 1%:num_set + fprintf('**********************\n'); + fprintf('Method_%d: %s; Set: %s\n', idx_method, methods{idx_method}, dataset{idx_set}); + for sigma = sigma_current%[10, 30, 50, 70] + filepaths = []; + for idx_ext = 1:length(ext) + filepaths = cat(1, filepaths, dir(fullfile(path_HR, dataset{idx_set}, ['N', num2str(sigma)], ext{idx_ext}))); + end + PSNR_all = zeros(1, length(filepaths)); + SSIM_all = zeros(1, length(filepaths)); + for idx_im = 1:length(filepaths) + name_HR = filepaths(idx_im).name; + name_SR = strrep(name_HR, 'HQ', method_name); + im_HR = imread(fullfile(path_HR, dataset{idx_set}, ['N', num2str(sigma)], name_HR)); + im_SR = imread(fullfile([methods{idx_method}, '/results'], dataset{idx_set}, ['N', num2str(sigma)], name_SR)); + im_HR = double(im_HR); + im_SR = double(im_SR); + % calculate PSNR, SSIM + PSNR_all(idx_im) = csnr(im_HR, im_SR, 0, 0); + [~, SSIM_all(idx_im)] = Cal_PSNRSSIM(im_HR, im_SR, 0, 0); + + fprintf('x%d %d %s: PSNR= %f SSIM= %f\n', sigma, idx_im, name_HR, PSNR_all(idx_im), SSIM_all(idx_im)); + + end + fprintf('--------Mean--------\n'); + fprintf('x%d: PSNR= %f, SSIM= %f \n', sigma, mean(PSNR_all), mean(SSIM_all)); + end + end +end + +toc +end +function s=csnr(A,B,row,col) + +[n,m,ch]=size(A); + +if ch==1 + e=A-B; + e=e(row+1:n-row,col+1:m-col); + me=mean(mean(e.^2)); + s=10*log10(255^2/me); +else + e=A-B; + e=e(row+1:n-row,col+1:m-col,:); + e1=e(:,:,1);e2=e(:,:,2);e3=e(:,:,3); + me1=mean(mean(e1.^2)); + me2=mean(mean(e2.^2)); + me3=mean(mean(e3.^2)); + mse=(me1+me2+me3)/3; + s = 10*log10(255^2/mse); +% s(1)=10*log10(255^2/me1); +% s(2)=10*log10(255^2/me2); +% s(3)=10*log10(255^2/me3); +end +end + +function [psnr_cur, ssim_cur] = Cal_PSNRSSIM(A,B,row,col) + + +[n,m,ch]=size(B); +A = A(row+1:n-row,col+1:m-col,:); +B = B(row+1:n-row,col+1:m-col,:); +A=double(A); % Ground-truth +B=double(B); % + +e=A(:)-B(:); +mse=mean(e.^2); +psnr_cur=10*log10(255^2/mse); + +if ch==1 + [ssim_cur, ~] = ssim_index(A, B); +else + ssim_cur = (ssim_index(A(:,:,1), B(:,:,1)) + ssim_index(A(:,:,2), B(:,:,2)) + ssim_index(A(:,:,3), B(:,:,3)))/3; +end +end + +function [mssim, ssim_map] = ssim_index(img1, img2, K, window, L) + +%======================================================================== +%SSIM Index, Version 1.0 +%Copyright(c) 2003 Zhou Wang +%All Rights Reserved. +% +%The author is with Howard Hughes Medical Institute, and Laboratory +%for Computational Vision at Center for Neural Science and Courant +%Institute of Mathematical Sciences, New York University. +% +%---------------------------------------------------------------------- +%Permission to use, copy, or modify this software and its documentation +%for educational and research purposes only and without fee is hereby +%granted, provided that this copyright notice and the original authors' +%names appear on all copies and supporting documentation. This program +%shall not be used, rewritten, or adapted as the basis of a commercial +%software or hardware product without first obtaining permission of the +%authors. The authors make no representations about the suitability of +%this software for any purpose. It is provided "as is" without express +%or implied warranty. +%---------------------------------------------------------------------- +% +%This is an implementation of the algorithm for calculating the +%Structural SIMilarity (SSIM) index between two images. Please refer +%to the following paper: +% +%Z. Wang, A. C. Bovik, H. R. Sheikh, and E. P. Simoncelli, "Image +%quality assessment: From error measurement to structural similarity" +%IEEE Transactios on Image Processing, vol. 13, no. 1, Jan. 2004. +% +%Kindly report any suggestions or corrections to zhouwang@ieee.org +% +%---------------------------------------------------------------------- +% +%Input : (1) img1: the first image being compared +% (2) img2: the second image being compared +% (3) K: constants in the SSIM index formula (see the above +% reference). defualt value: K = [0.01 0.03] +% (4) window: local window for statistics (see the above +% reference). default widnow is Gaussian given by +% window = fspecial('gaussian', 11, 1.5); +% (5) L: dynamic range of the images. default: L = 255 +% +%Output: (1) mssim: the mean SSIM index value between 2 images. +% If one of the images being compared is regarded as +% perfect quality, then mssim can be considered as the +% quality measure of the other image. +% If img1 = img2, then mssim = 1. +% (2) ssim_map: the SSIM index map of the test image. The map +% has a smaller size than the input images. The actual size: +% size(img1) - size(window) + 1. +% +%Default Usage: +% Given 2 test images img1 and img2, whose dynamic range is 0-255 +% +% [mssim ssim_map] = ssim_index(img1, img2); +% +%Advanced Usage: +% User defined parameters. For example +% +% K = [0.05 0.05]; +% window = ones(8); +% L = 100; +% [mssim ssim_map] = ssim_index(img1, img2, K, window, L); +% +%See the results: +% +% mssim %Gives the mssim value +% imshow(max(0, ssim_map).^4) %Shows the SSIM index map +% +%======================================================================== + + +if (nargin < 2 || nargin > 5) + ssim_index = -Inf; + ssim_map = -Inf; + return; +end + +if (size(img1) ~= size(img2)) + ssim_index = -Inf; + ssim_map = -Inf; + return; +end + +[M N] = size(img1); + +if (nargin == 2) + if ((M < 11) || (N < 11)) + ssim_index = -Inf; + ssim_map = -Inf; + return + end + window = fspecial('gaussian', 11, 1.5); % + K(1) = 0.01; % default settings + K(2) = 0.03; % + L = 255; % +end + +if (nargin == 3) + if ((M < 11) || (N < 11)) + ssim_index = -Inf; + ssim_map = -Inf; + return + end + window = fspecial('gaussian', 11, 1.5); + L = 255; + if (length(K) == 2) + if (K(1) < 0 || K(2) < 0) + ssim_index = -Inf; + ssim_map = -Inf; + return; + end + else + ssim_index = -Inf; + ssim_map = -Inf; + return; + end +end + +if (nargin == 4) + [H W] = size(window); + if ((H*W) < 4 || (H > M) || (W > N)) + ssim_index = -Inf; + ssim_map = -Inf; + return + end + L = 255; + if (length(K) == 2) + if (K(1) < 0 || K(2) < 0) + ssim_index = -Inf; + ssim_map = -Inf; + return; + end + else + ssim_index = -Inf; + ssim_map = -Inf; + return; + end +end + +if (nargin == 5) + [H W] = size(window); + if ((H*W) < 4 || (H > M) || (W > N)) + ssim_index = -Inf; + ssim_map = -Inf; + return + end + if (length(K) == 2) + if (K(1) < 0 || K(2) < 0) + ssim_index = -Inf; + ssim_map = -Inf; + return; + end + else + ssim_index = -Inf; + ssim_map = -Inf; + return; + end +end + +C1 = (K(1)*L)^2; +C2 = (K(2)*L)^2; +window = window/sum(sum(window)); +img1 = double(img1); +img2 = double(img2); + +mu1 = filter2(window, img1, 'valid'); +mu2 = filter2(window, img2, 'valid'); +mu1_sq = mu1.*mu1; +mu2_sq = mu2.*mu2; +mu1_mu2 = mu1.*mu2; +sigma1_sq = filter2(window, img1.*img1, 'valid') - mu1_sq; +sigma2_sq = filter2(window, img2.*img2, 'valid') - mu2_sq; +sigma12 = filter2(window, img1.*img2, 'valid') - mu1_mu2; + +if (C1 > 0 & C2 > 0) + ssim_map = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))./((mu1_sq + mu2_sq + C1).*(sigma1_sq + sigma2_sq + C2)); +else + numerator1 = 2*mu1_mu2 + C1; + numerator2 = 2*sigma12 + C2; + denominator1 = mu1_sq + mu2_sq + C1; + denominator2 = sigma1_sq + sigma2_sq + C2; + ssim_map = ones(size(mu1)); + index = (denominator1.*denominator2 > 0); + ssim_map(index) = (numerator1(index).*numerator2(index))./(denominator1(index).*denominator2(index)); + index = (denominator1 ~= 0) & (denominator2 == 0); + ssim_map(index) = numerator1(index)./denominator1(index); +end + +mssim = mean2(ssim_map); + +end \ No newline at end of file diff --git a/DN_RGB/experiment/test/config.txt b/DN_RGB/experiment/test/config.txt new file mode 100644 index 0000000000000000000000000000000000000000..5704ff90528a88a73a8e4a4a20c5183c725caaff --- /dev/null +++ b/DN_RGB/experiment/test/config.txt @@ -0,0 +1,2217 @@ +2020-11-12-16:15:40 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTS_RES +act: relu +pre_train: ../experiment/RAFTS_RES/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 5 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-16:16:26 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RESNET +act: relu +pre_train: ../experiment/RAFTS_RES/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 5 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-16:17:51 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RESNET +act: relu +pre_train: ../experiment/RAFTS_RES/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 5 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-16:21:08 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RESNET +act: relu +pre_train: ../experiment/RAFTS_RES/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 5 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-16:22:01 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RESNET +act: relu +pre_train: ../experiment/RAFTS_RES/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 1 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-16:22:30 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RESNET +act: relu +pre_train: ../experiment/RAFTS_RES/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 1 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-16:45:50 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETSINGLE +act: relu +pre_train: ../experiment/RAFTSINGLE_N50_R1/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 1 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-17:15:51 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETSINGLE +act: relu +pre_train: ../experiment/RAFTSINGLE_N50_R1/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 1 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-18:06:46 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETSINGLE +act: relu +pre_train: ../experiment/RAFTSINGLE_N50_R1/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 1 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-19:10:36 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETS +act: relu +pre_train: ../experiment/RAFTS_N50_R4/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 4 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-19:11:54 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETS +act: relu +pre_train: ../experiment/RAFTS_N50_R4_nobn/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 4 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-19:12:11 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETS +act: relu +pre_train: ../experiment/RAFTS_N50_R4_nobn/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 4 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: none +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-19:54:05 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETS +act: relu +pre_train: ../experiment/RAFTS_N50_R4/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 4 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-19:54:26 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETSINGLE +act: relu +pre_train: ../experiment/RAFTSINGLE_N50_R1/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 1 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-19:56:06 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RESNET +act: relu +pre_train: ../experiment/RAFTS_RES/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 1 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-20:08:50 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RESNET +act: relu +pre_train: ../experiment/RAFTS_RES/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 1 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-20:26:28 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RESNET +act: relu +pre_train: ../experiment/RAFTS_RES/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 1 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-21:10:01 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETSINGLE +act: relu +pre_train: ../experiment/RAFTSINGLE_N50_R1/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 1 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-21:11:52 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETS +act: relu +pre_train: ../experiment/RAFTSINGLE_N50_R4_bn/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 4 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-21:12:07 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETS +act: relu +pre_train: ../experiment/RAFTS_N50_R4_bn/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 4 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-21:36:48 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETS +act: relu +pre_train: ../experiment/RAFTS_N50_R4_bn/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 4 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-22:04:54 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETS +act: relu +pre_train: ../experiment/RAFTS_N50_R4_bn/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 4 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-23:36:47 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETS +act: relu +pre_train: ../experiment/RAFTS_N50_R4_bn/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 4 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: batch +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-12-23:58:18 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETS +act: relu +pre_train: ../experiment/RAFTS_N50_R4_nobn/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 4 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: none +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-13-14:58:03 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETS +act: relu +pre_train: ../experiment/RAFTS_N50_R4_nobn/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 4 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: none +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-13-15:46:28 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETS +act: relu +pre_train: ../experiment/RAFTS_N50_R4_nobn/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 4 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: none +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-13-15:56:28 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETS +act: relu +pre_train: ../experiment/RAFTS_N50_R4_nobn/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 4 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: none +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-13-16:06:13 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETS +act: relu +pre_train: ../experiment/RAFTS_N50_R4_nobn/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 4 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: none +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-13-23:26:41 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETS +act: relu +pre_train: ../experiment/RAFTS_N50_R4_nobn/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 4 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: none +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-13-23:32:25 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETS +act: relu +pre_train: ../experiment/RAFTS_N50_R4_nobn/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 4 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: none +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-14-11:57:34 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETS +act: relu +pre_train: ../experiment/RAFTS_N50_R4_nobn/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 4 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: none +lamradius: 23 +decay_gamma: 0.8 +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-14-12:02:39 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETS +act: relu +pre_train: ../experiment/RAFTS_N50_R4_nobn/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 4 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: none +lamradius: 23 +decay_gamma: 0.8 +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + +2020-11-15-13:53:04 + +debug: False +template: . +n_threads: 18 +cpu: False +n_GPUs: 1 +seed: 1 +dir_data: /data/ssd/public/liuhy/DNDM/dataset +data_train: ['DIV2K'] +data_test: ['Kodak24', 'CBSD68', 'Urban100'] +data_range: 1-800/943-1000 +ext: sep +scale: [50] +patch_size: 192 +rgb_range: 1 +n_colors: 3 +chop: False +no_augment: False +model: RAFTNETS +act: relu +pre_train: ../experiment/RAFTS_N50_R4_nobn/model/model_best.pt +extend: . +n_resblocks: 20 +recurrence: 4 +n_feats: 64 +res_scale: 1 +shift_mean: True +amp: False +detach: False +spectral: False +dilation: False +precision: single +normalization: none +lamradius: 23 +decay_gamma: 0.8 +G0: 64 +RDNkSize: 3 +RDNconfig: B +depth: 12 +n_resgroups: 10 +reduction: 16 +reset: False +test_every: 1000 +epochs: 1000 +batch_size: 16 +split_batch: 1 +self_ensemble: False +test_only: True +gan_k: 1 +lr: 0.0001 +decay: 200-400-600-800 +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +gclip: 0 +loss: 1*L1 +skip_threshold: 100000000.0 +save: test +load: +resume: 0 +save_models: False +print_every: 100 +save_results: True +save_gt: False + diff --git a/DN_RGB/experiment/test/log.txt b/DN_RGB/experiment/test/log.txt new file mode 100644 index 0000000000000000000000000000000000000000..69ec648019399a1772c7fcdbae0c6644e4b4c605 --- /dev/null +++ b/DN_RGB/experiment/test/log.txt @@ -0,0 +1,6416 @@ +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.472 (Best: 29.472 @epoch 1) +[CBSD68 x50] PSNR: 28.193 (Best: 28.193 @epoch 1) +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.472 (Best: 29.472 @epoch 1) +[CBSD68 x50] PSNR: 28.193 (Best: 28.193 @epoch 1) +[Urban100 x50] PSNR: 28.780 (Best: 28.780 @epoch 1) +Forward: 37.89s + +Saving... +Total: 39.37s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (norm_v): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.282 (Best: 29.282 @epoch 1) +[CBSD68 x50] PSNR: 28.115 (Best: 28.115 @epoch 1) +[Urban100 x50] PSNR: 28.643 (Best: 28.643 @epoch 1) +Forward: 72.18s + +Saving... +Total: 73.60s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (norm_v): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.282 (Best: 29.282 @epoch 1) +[CBSD68 x50] PSNR: 28.115 (Best: 28.115 @epoch 1) +[Urban100 x50] PSNR: 28.643 (Best: 28.643 @epoch 1) +Forward: 72.22s + +Saving... +Total: 73.46s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (norm_v): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.282 (Best: 29.282 @epoch 1) +[CBSD68 x50] PSNR: 28.115 (Best: 28.115 @epoch 1) +[Urban100 x50] PSNR: 28.643 (Best: 28.643 @epoch 1) +Forward: 72.12s + +Saving... +Total: 73.53s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (norm_v): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (gru): ConvGRU( + (convz): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convr): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convq): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): Identity() + (norm_v): Identity() + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (gru): ConvGRU( + (convz): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convr): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convq): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.223 (Best: 29.223 @epoch 1) +[CBSD68 x50] PSNR: 28.064 (Best: 28.064 @epoch 1) +[Urban100 x50] PSNR: 28.575 (Best: 28.575 @epoch 1) +Forward: 279.44s + +Saving... +Total: 280.89s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (norm_v): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.289 (Best: 29.289 @epoch 1) +[CBSD68 x50] PSNR: 28.122 (Best: 28.122 @epoch 1) +[Urban100 x50] PSNR: 28.655 (Best: 28.655 @epoch 1) +Forward: 72.17s + +Saving... +Total: 73.57s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.472 (Best: 29.472 @epoch 1) +[CBSD68 x50] PSNR: 28.193 (Best: 28.193 @epoch 1) +[Urban100 x50] PSNR: 28.780 (Best: 28.780 @epoch 1) +Forward: 38.03s + +Saving... +Total: 39.50s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.472 (Best: 29.472 @epoch 1) +[CBSD68 x50] PSNR: 28.193 (Best: 28.193 @epoch 1) +[Urban100 x50] PSNR: 28.780 (Best: 28.780 @epoch 1) +Forward: 37.44s + +Saving... +Total: 38.81s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.472 (Best: 29.472 @epoch 1) +[CBSD68 x50] PSNR: 28.193 (Best: 28.193 @epoch 1) +[Urban100 x50] PSNR: 28.780 (Best: 28.780 @epoch 1) +Forward: 37.62s + +Saving... +Total: 39.31s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (norm_v): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.292 (Best: 29.292 @epoch 1) +[CBSD68 x50] PSNR: 28.122 (Best: 28.122 @epoch 1) +[Urban100 x50] PSNR: 28.655 (Best: 28.655 @epoch 1) +Forward: 72.21s + +Saving... +Total: 73.83s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (norm_v): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (gru): ConvGRU( + (convz): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convr): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convq): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.139 (Best: 29.139 @epoch 1) +[CBSD68 x50] PSNR: 28.007 (Best: 28.007 @epoch 1) +[Urban100 x50] PSNR: 28.418 (Best: 28.418 @epoch 1) +Forward: 283.28s + +Saving... +Total: 284.84s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (norm_v): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (gru): ConvGRU( + (convz): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convr): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convq): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.139 (Best: 29.139 @epoch 1) +[CBSD68 x50] PSNR: 28.007 (Best: 28.007 @epoch 1) +[Urban100 x50] PSNR: 28.418 (Best: 28.418 @epoch 1) +Forward: 281.00s + +Saving... +Total: 282.34s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (norm_v): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (gru): ConvGRU( + (convz): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convr): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convq): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.139 (Best: 29.139 @epoch 1) +[CBSD68 x50] PSNR: 28.007 (Best: 28.007 @epoch 1) +[Urban100 x50] PSNR: 28.418 (Best: 28.418 @epoch 1) +Forward: 280.89s + +Saving... +Total: 282.36s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (norm_v): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (gru): ConvGRU( + (convz): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convr): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convq): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.166 (Best: 29.166 @epoch 1) +[CBSD68 x50] PSNR: 28.028 (Best: 28.028 @epoch 1) +[Urban100 x50] PSNR: 28.449 (Best: 28.449 @epoch 1) +Forward: 281.16s + +Saving... +Total: 282.54s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): Identity() + (norm_v): Identity() + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (gru): ConvGRU( + (convz): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convr): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convq): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.297 (Best: 29.297 @epoch 1) +[CBSD68 x50] PSNR: 28.105 (Best: 28.105 @epoch 1) +[Urban100 x50] PSNR: 28.731 (Best: 28.731 @epoch 1) +Forward: 281.40s + +Saving... +Total: 282.97s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): Identity() + (norm_v): Identity() + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (gru): ConvGRU( + (convz): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convr): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convq): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.310 (Best: 29.310 @epoch 1) +[CBSD68 x50] PSNR: 28.126 (Best: 28.126 @epoch 1) +[Urban100 x50] PSNR: 28.781 (Best: 28.781 @epoch 1) +Forward: 323.39s + +Saving... +Total: 324.63s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): Identity() + (norm_v): Identity() + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (gru): ConvGRU( + (convz): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convr): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convq): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.324 (Best: 29.324 @epoch 1) +[CBSD68 x50] PSNR: 28.129 (Best: 28.129 @epoch 1) +[Urban100 x50] PSNR: 28.816 (Best: 28.816 @epoch 1) +Forward: 322.08s + +Saving... +Total: 323.38s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): Identity() + (norm_v): Identity() + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (gru): ConvGRU( + (convz): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convr): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convq): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.323 (Best: 29.323 @epoch 1) +[CBSD68 x50] PSNR: 28.131 (Best: 28.131 @epoch 1) +[Urban100 x50] PSNR: 28.821 (Best: 28.821 @epoch 1) +Forward: 322.52s + +Saving... +Total: 323.97s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): Identity() + (norm_v): Identity() + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (gru): ConvGRU( + (convz): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convr): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convq): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.323 (Best: 29.323 @epoch 1) +[CBSD68 x50] PSNR: 28.131 (Best: 28.131 @epoch 1) +[Urban100 x50] PSNR: 28.821 (Best: 28.821 @epoch 1) +Forward: 322.30s + +Saving... +Total: 323.74s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): Identity() + (norm_v): Identity() + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (gru): ConvGRU( + (convz): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convr): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convq): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: nan (Best: nan @epoch 1) +[CBSD68 x50] PSNR: nan (Best: nan @epoch 1) +[Urban100 x50] PSNR: nan (Best: nan @epoch 1) +Forward: 1.53s + +Saving... +Total: 2.53s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): Identity() + (norm_v): Identity() + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (gru): ConvGRU( + (convz): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convr): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convq): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.347 (Best: 29.347 @epoch 1) +[CBSD68 x50] PSNR: 28.151 (Best: 28.151 @epoch 1) +[Urban100 x50] PSNR: 28.841 (Best: 28.841 @epoch 1) +Forward: 282.89s + +Saving... +Total: 284.29s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): Identity() + (norm_v): Identity() + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (gru): ConvGRU( + (convz): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convr): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convq): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: nan (Best: nan @epoch 1) +[CBSD68 x50] PSNR: nan (Best: nan @epoch 1) +[Urban100 x50] PSNR: nan (Best: nan @epoch 1) +Forward: 1.59s + +Saving... +Total: 2.59s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): Identity() + (norm_v): Identity() + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (gru): ConvGRU( + (convz): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convr): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convq): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.347 (Best: 29.347 @epoch 1) +[CBSD68 x50] PSNR: 28.151 (Best: 28.151 @epoch 1) +[Urban100 x50] PSNR: 28.841 (Best: 28.841 @epoch 1) +Forward: 279.11s + +Saving... +Total: 280.52s + +RAFTNET( + (sub_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (add_mean): MeanShift(3, 3, kernel_size=(1, 1), stride=(1, 1)) + (hidden_encoder): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (head): Sequential( + (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + ) + (body): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (3): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (4): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (5): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (6): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (7): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (8): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (9): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (10): LambdaLayer( + (to_q): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_k): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (to_v): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False) + (norm_q): Identity() + (norm_v): Identity() + (pos_conv): Conv3d(4, 16, kernel_size=(1, 23, 23), stride=(1, 1, 1), padding=(0, 11, 11)) + ) + (11): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (12): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (13): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (14): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (15): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (16): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (17): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (18): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (19): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (20): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (21): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (tail): Sequential( + (0): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (1): ResBlock( + (body): Sequential( + (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (1): PReLU(num_parameters=1) + (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + ) + (2): Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) + (gru): ConvGRU( + (convz): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convr): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (convq): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + ) +) + +Evaluation: +[Kodak24 x50] PSNR: 29.347 (Best: 29.347 @epoch 1) +[CBSD68 x50] PSNR: 28.151 (Best: 28.151 @epoch 1) +[Urban100 x50] PSNR: 28.841 (Best: 28.841 @epoch 1) +Forward: 279.71s + +Saving... +Total: 280.89s + diff --git a/DN_RGB/experiment/test/results-CBSD68/101085_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/101085_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..01b0e9284e83b3e74d1d1b75bd0e8c0848d48147 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/101085_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/101087_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/101087_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..fb4088b52ad99f56e93315a86492d92434233052 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/101087_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/102061_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/102061_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..4b7af660705ef9c7eeb524cc02114439a26a4ea5 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/102061_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/103070_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/103070_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..86c4eb8ad87493d6fae0b62f26636e6e396c69e7 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/103070_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/105025_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/105025_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..3a2968e22936e4fe6181960fc12e0c43486476f1 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/105025_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/106024_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/106024_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..765ee2a2f73315a0ef8af6bc7f9b00db8abd9ac5 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/106024_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/108005_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/108005_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..ec177755b881dc6652a26b665613373cdf21d27a Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/108005_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/108070_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/108070_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..e538aeaff43631e8dbbc38a193c998d71f5cf35f Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/108070_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/108082_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/108082_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..0d8e56ecd12b1f6b6759d0c5e62149cbedbba8b2 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/108082_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/109053_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/109053_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..5aa8281f83e8c5e2268d07172182ba0eb8b41077 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/109053_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/119082_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/119082_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..573d148bcaacefc6bdc52b0a92aba9e8db3d88ae Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/119082_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/12084_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/12084_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..a5ecdd8027f2df38d99672b633840f80fafb3a9a Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/12084_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/123074_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/123074_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..9ba6c25463329bb03026e2746e24160d55ec1d37 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/123074_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/126007_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/126007_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..e89e90d14d8fc8439b31dd65227b605f0abda4d0 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/126007_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/130026_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/130026_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..27f6df61a60f727a2fc722957f48500cd555af03 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/130026_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/134035_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/134035_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..db0f66e943601226ba2d460375349d54bdcf7c59 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/134035_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/14037_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/14037_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..2b7fa978e2a44cd9fb6302f75f4c9886ee102f96 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/14037_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/143090_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/143090_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..7ffbb3d3834d70994f9c125cae7635f0fef53bf9 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/143090_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/145086_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/145086_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..7430ead42aa3626b91f7a8b4475c57e34bbd758d Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/145086_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/147091_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/147091_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..8997a4af51da252e0a2bc82a39a7ff3d92c99c6b Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/147091_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/148026_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/148026_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..7933e218385a8a1c222e48d7063c14112ed06091 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/148026_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/148089_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/148089_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..75c0d4e6f7ea5889e212fce75503e82815927f3e Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/148089_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/157055_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/157055_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..3cb9a6ce1508fe7df4a24512db4d28a26fff4400 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/157055_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/159008_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/159008_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..2b08bd4cc2b58e55481bc0b08ecad81e286c200e Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/159008_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/160068_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/160068_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..3ee1e4da41f25e4fb2688fccb053dfbb5f931c17 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/160068_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/16077_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/16077_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..b24cdc0938065b635d867b3134a1aac2ea5b78ab Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/16077_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/163085_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/163085_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..5ed0d5c1304a1897532059c97d1077c4952173dc Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/163085_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/167062_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/167062_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..cd5bcd69e218461ee0e6327b963bc1e23c31cea0 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/167062_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/167083_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/167083_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..811f8958cfef3aabc4a980950732834e9cf1a570 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/167083_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/170057_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/170057_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..302a357d8ef4e1235d9455a3af5906c6810ae568 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/170057_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/175032_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/175032_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..7a83598ca7a467e9350defbd7cc1398b4b365ab9 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/175032_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/175043_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/175043_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..77207fe77a2e9c54240e3f6bf5acb1262650727d Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/175043_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/182053_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/182053_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..e43d30b83f28020a51754e6f05381d585243f8fc Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/182053_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/189080_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/189080_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..9db83d1bfd7440f141b3f251cd35ad302f0f9514 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/189080_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/19021_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/19021_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..4426a7367525731d70b16941f4298e312fff4b8e Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/19021_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/196073_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/196073_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..f31c6beff18b49c8e76c522908f1160e49a5069d Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/196073_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/197017_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/197017_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..4a399a2ce51f8cf9f4bc8123256572d1f906e788 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/197017_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/208001_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/208001_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..40a730603406d529fc2fce1d97485796d26653c3 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/208001_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/210088_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/210088_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..785232c6372947987e591405bdc54da43482fc16 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/210088_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/21077_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/21077_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..c6d5bf762aefde62454b029fba6f597408626e99 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/21077_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/216081_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/216081_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..6d20dfd7d302ceef82bae60c17e08b0bafe00902 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/216081_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/219090_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/219090_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..2bb4106bcb2a230bea9803853943478a5a8af2f1 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/219090_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/220075_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/220075_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..718bfd4b7b70db5c98a147bb26ab38fbf6654779 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/220075_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/223061_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/223061_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..332aa30ca4932f7b655e5dd9f15bde939159cf9b Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/223061_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/227092_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/227092_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..182508aada1e4628dd2245a49961441280ca296b Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/227092_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/229036_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/229036_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..01f170afa7a624dc91fe3b952ba3978e7c4de2f4 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/229036_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/236037_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/236037_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..b2ef60a4244a5e415a0f1e3bc71b4354f4dcaaf2 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/236037_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/24077_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/24077_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..ff1185e8b6c841afa504bbcf3ab40141f262bc26 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/24077_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/241004_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/241004_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..7e16027aeb543f8965f9287d4b093d046b1e98fc Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/241004_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/241048_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/241048_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..824de7c3a172bffd32254ed670c3e33ba4df50e2 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/241048_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/253027_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/253027_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..a0f2b5f09d6b3e7da8395bfc58ea39292ca8f3bb Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/253027_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/253055_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/253055_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..f919b67fac38354bcaf184817906b39e119332ba Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/253055_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/260058_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/260058_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..fac206ff620c925ba745ff6550f6f15fdd205a04 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/260058_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/271035_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/271035_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..2dd5868d1d9582861a4ae7f1e280342697f52af0 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/271035_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/285079_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/285079_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..c1921759b4b485f27359ae71b03552a977d26e28 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/285079_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/291000_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/291000_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..ff3085427ac3b412b01e470b84bde2f5c1bd4265 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/291000_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/295087_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/295087_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..e30571d818708f15b0639000774ae8330c54e113 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/295087_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/296007_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/296007_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..bd34223f4d778b8787ac7fee0e9a7e2c56042d45 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/296007_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/296059_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/296059_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..b787a1c540c646f2d772d63e3d1e180002c1dd0e Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/296059_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/299086_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/299086_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..afffe4665482d48b7aa00d2bb61fc8dd5c630f3d Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/299086_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/300091_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/300091_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..ec1295e74059324cb3781a6d1425f9dd81cc89ee Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/300091_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/302008_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/302008_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..59d26a3dea60029db1bfc316aee2d5bf0838e772 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/302008_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/304034_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/304034_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..a4ac7bb81931aae8915982c639be2f769b64de68 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/304034_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/304074_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/304074_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..83b70216d3c5e7e0e9a8c3c71ca4f02e1745663f Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/304074_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/306005_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/306005_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..577009a08758519139c6c0cb2fad7303dae42a98 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/306005_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/3096_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/3096_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..192ecc8f19b1a3e68b1440fb673a083dbd36acaa Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/3096_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/33039_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/33039_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..6184c894599bc7c51492007425c681ce39f5752e Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/33039_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-CBSD68/351093_x50_DN.png b/DN_RGB/experiment/test/results-CBSD68/351093_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..548ed912ec6bddc24af8a3205ba080e0753694d6 Binary files /dev/null and b/DN_RGB/experiment/test/results-CBSD68/351093_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim01_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim01_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..857a064402a0dbe908f2b678823f10cf0c15c574 Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim01_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim02_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim02_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..84b16a06e140f5008eaa5043341a077c53b7f09f Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim02_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim03_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim03_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..60aa2680f20c57eb01f5c999cdb19ec46e60a65a Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim03_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim04_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim04_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..f13f7861f118e8e9ce6b77714c7419a96106d13c Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim04_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim05_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim05_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..9eec88b6df5984f5a469d5f23b3c847f1e311425 Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim05_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim06_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim06_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..3060e3e1d0ce93f47d9abf5ae70d21acf0df97f7 Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim06_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim07_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim07_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..595bb0e16ac4fc9597f989f454a446c4917ce350 Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim07_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim08_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim08_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..204a2f1013dda0a265adcbc47d4d00ad5b903ff2 Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim08_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim09_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim09_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..d8cd8af05e3c40c1b0fd525964e225d286407a7f Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim09_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim10_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim10_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..cb169e4c12d039a593a00a1b67f6a4ab3fe15a7e Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim10_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim11_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim11_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..6f15b76b615c4580865a828b4c8197172eb586b9 Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim11_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim12_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim12_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..541dc19ae4193a938f42ba0410bf5a272e3e878b Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim12_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim13_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim13_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..418b12d3808985b23c196fbc8f04a8fa679814df Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim13_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim14_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim14_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..9dd83be165a94bb73c75de2481c9d737bfbbaa41 Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim14_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim15_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim15_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..dd289bafd97d33e6719ea28bb525fda15f2eef0c Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim15_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim16_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim16_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..3eca38566cc1bee0d71f1d30c851499db8b75db9 Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim16_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim17_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim17_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..d6ae4eb352558755ce9c23f59c4e788471a2e31e Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim17_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim18_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim18_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..24a98689377d758c18030495c09028de3b16007a Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim18_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim19_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim19_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..0a398eb773bf5f3fed7bcb4d57b70edaf73b0bf2 Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim19_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim20_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim20_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..7a046489b5ff2c2a49b143f38d0c890a88d3fb57 Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim20_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim21_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim21_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..524025ce54ca4f74ea466075882c95068c202cea Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim21_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim22_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim22_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..0efcfcfd69b0d0a6aa002dceb60800a7f152b58e Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim22_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim23_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim23_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..411c28a4e91e15f3c5408cb3b7fadf6c0d9ebfa0 Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim23_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Kodak24/kodim24_x50_DN.png b/DN_RGB/experiment/test/results-Kodak24/kodim24_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..9887c68dcd84bee9ebe11f2bc671024935058bf1 Binary files /dev/null and b/DN_RGB/experiment/test/results-Kodak24/kodim24_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img001_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img001_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..dc92841fc37e78e18b1d99afd06fe03e83e7cb54 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img001_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img002_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img002_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..d795dcd16a37c040169015bcfcb38052f10c8b6a --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img002_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2c5832cedcec8c1bb4cbcaa97d105e3dbeb88b507356114fa659a5bda0d7d2d5 +size 1147201 diff --git a/DN_RGB/experiment/test/results-Urban100/img003_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img003_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..e0dc22ca2e6f449d8ac29d6c47aaa68b2ca3cf3b --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img003_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e249dc27b1e97cb2bd572f93c77b79a8ff85a64510d4a85b8eec4c8b7e473488 +size 1151205 diff --git a/DN_RGB/experiment/test/results-Urban100/img004_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img004_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..9f746290b228699b37c50acfd6c3c4aca995a96b --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img004_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cbeeb4eba4bb4ff9d177e87c19746a79e1203bc570cbe5a11ac7e87cc1442993 +size 1026355 diff --git a/DN_RGB/experiment/test/results-Urban100/img005_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img005_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..e8dc5113b17f6cdd158952cfe2bdde227feb3a22 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img005_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img006_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img006_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..2d9776d714fe9503e31cdad979b3251deec68d97 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img006_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4bd63720c08efe97c1d4bdb14d6da3c36b186e725b6a1c62e5b1b16d8cd67eb9 +size 2016059 diff --git a/DN_RGB/experiment/test/results-Urban100/img007_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img007_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..6fa9e1dc2fd1ad7ffcee90d105d2ba22f0090421 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img007_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img008_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img008_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..42106666e0932f1ae54d5132b88dda90df0cf1ba --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img008_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d1019015289b4eb4d63de9ada79dc301d81b8c400f8e8b9c32e2a29b673363cf +size 1188683 diff --git a/DN_RGB/experiment/test/results-Urban100/img009_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img009_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..76194a5af612bb842f3359bf3814f2cb296e0dbc Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img009_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img010_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img010_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..8ff02e96ad31eb9ec62525735d81fbad6f87e310 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img010_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img011_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img011_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..5411f27cd11ba86f08e1921008bb0c68d81f2e3a Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img011_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img012_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img012_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..1153a2a7b660fa38ec09500abf0240ac1aad28b0 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img012_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ecded1e755c76b3a8dd3d925f178e9d6b33a84b01cb4adf23d2856bd98b0b44a +size 1376816 diff --git a/DN_RGB/experiment/test/results-Urban100/img013_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img013_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..d42e0c876b25b33aeb474173eb9c1283a6f9d4e4 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img013_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:80fd6d50831d6283d2e02368c0f1c3515417d5d96e85daf4b4690bc288fe04f3 +size 1117331 diff --git a/DN_RGB/experiment/test/results-Urban100/img014_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img014_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..e6276450109944d0838e2a58f549396e0db80ae4 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img014_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a9f62b019ac7c28092f644365ba88e4a2ca8267c230517c76e6fcfa41ca21a88 +size 1678673 diff --git a/DN_RGB/experiment/test/results-Urban100/img015_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img015_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..7a31250004e7fc6492c251c27e89c5328901a60b --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img015_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:45b9f0f7273a2c3fc5f26e239109f1f1b074850f490515ebf5f52213dc6a65ad +size 1191353 diff --git a/DN_RGB/experiment/test/results-Urban100/img016_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img016_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..89b2312329ab024191af26b6a3d1027f0702a3c6 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img016_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img017_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img017_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..b93adbdbbe8c967de446429f6bf2d91822bd47e9 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img017_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e08414b8fb2377adbe39790327f06c98518eefb81a8d089cf82d797375dee5bc +size 1021065 diff --git a/DN_RGB/experiment/test/results-Urban100/img018_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img018_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..14fe88b5736b11d6d2748f900e4402dbdf4a3c20 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img018_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0fc8e17bbd3bd5519299fb7db0b30bc799e33b2071f722e2dc1f69fdd0ad821e +size 1267340 diff --git a/DN_RGB/experiment/test/results-Urban100/img019_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img019_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..8ba1cde48a0b0cb75831e2fa1f11fe867260ac3e --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img019_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:16c3eec32f14f6d41da87bc42e22d16c238a879bf6b6ee6d887875f33871e6a2 +size 1068660 diff --git a/DN_RGB/experiment/test/results-Urban100/img020_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img020_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..218974efe716914383c89887f246dfc7e84c1308 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img020_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8069a1c03f37f3d6c2905672cd2cf8c00156fac52b02607ac00548facaf159db +size 2107383 diff --git a/DN_RGB/experiment/test/results-Urban100/img021_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img021_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..c9442cfa91f97e044bc5bc8695416baa2f9af454 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img021_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img022_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img022_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..69c8b26f2bb6e465260a8a5115bfdae8d0d32364 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img022_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img023_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img023_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..1a06190f2e899f32b22f5b28e0fd97a65bff0ab6 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img023_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:06ed64557cb887a6c96369a16fca99f4b65937e3ed90d43e641e995ebcf33d1e +size 1443624 diff --git a/DN_RGB/experiment/test/results-Urban100/img024_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img024_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..aeba6cb8e7368fa43b3ad013aaac101cf6ce405a --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img024_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2020df38af4354a13fadbf80c9b0dd29b8a9896869ecbdf2e4d2f69ab185deee +size 1000546 diff --git a/DN_RGB/experiment/test/results-Urban100/img025_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img025_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..8e7224b8037b3409cc196a5a04a01bac29b71367 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img025_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img026_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img026_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..fc17194fb295b58e361f7cf1b9612be8ae86b5c6 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img026_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img027_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img027_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..21abd7063523d1051fb6a5f3fd02fe236e24ea43 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img027_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img028_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img028_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..54bedfe8e3df2598edc785fb6ba9edd7276cfd7f Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img028_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img029_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img029_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..021ac6a9b32936f393acfc5971e0804eac023abc Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img029_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img030_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img030_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..741000d53604bf1ae8bb64143e8034350136c71f --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img030_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0d8a573bd26e2477c5012659b9523a9958139aa1df8ff29246a60d459f38452f +size 1031639 diff --git a/DN_RGB/experiment/test/results-Urban100/img031_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img031_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..bed1c6e4eeb7d19304f7a1057f6bcfe13bcc1a99 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img031_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e97f5232b2927a79024e09f73848b544aff4180bdd8042e2c246c5b5763e5353 +size 1077272 diff --git a/DN_RGB/experiment/test/results-Urban100/img032_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img032_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..4b78bae2fd8b697d7ef16699e9c5b789f0858983 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img032_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img033_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img033_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..187f56b86bc79062a2dedd7135b12a240318a688 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img033_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img034_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img034_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..778c6208064ff374ecc2537b0997c909c5b8d5ff --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img034_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b448e3eb2bb163e1bf0fd101935a5c7f2081cf0e912815f261a7e98977319182 +size 1292368 diff --git a/DN_RGB/experiment/test/results-Urban100/img035_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img035_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..26e2659dbe2e6c7196f160518a800f26b536dffa Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img035_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img036_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img036_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..dbe991ea949f60c606b3fa4c400cb965aee9023e Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img036_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img037_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img037_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..e0ecbc5a027d281823649f2f39c6df402b5d637c --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img037_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b8b3cf4e9c775172c9c10854460c481c8912c3347f472a2fb1157bb894ba17be +size 1108177 diff --git a/DN_RGB/experiment/test/results-Urban100/img038_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img038_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..f0d1708dbe28e5ba81518df99ca8bd92c3ba298c --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img038_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5b4082cc1628c1f956ca3f91b5b38fc6d4e687e283446bcf0a7f8369da70d07d +size 1137129 diff --git a/DN_RGB/experiment/test/results-Urban100/img039_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img039_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..6b66c48c31c9663869f1d8e2b1e12594496ff33b --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img039_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5d8a3bb83726be9e37debbd8bd946cb12c5c974ea3038557c53fbd8b6407d364 +size 1270935 diff --git a/DN_RGB/experiment/test/results-Urban100/img040_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img040_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..8a65e9b8d7ff8817e3685f1a8b126b6367347733 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img040_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img041_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img041_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..25d92eb2e9ce676c6b41d3626747c067cbe49bea --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img041_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f7e3aaf162e7a2f65de5d1b8f709d36842bb7d3ce4bd2aa4db623f10b2679d3c +size 1122960 diff --git a/DN_RGB/experiment/test/results-Urban100/img042_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img042_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..2f283b8b43c73ab2270819455ae2a30f5009a1c8 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img042_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img043_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img043_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..c03b1df1efcc22c1d8e7c0754a83b08f81e382f0 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img043_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img044_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img044_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..ed8d831924c20f4aace56033c307e74e9e3b6db5 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img044_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img045_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img045_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..4fcc76601a838d4b3c30efcbfac5de2a0e0088fb --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img045_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6edd2c309fadb3bab5416683f69419bc296f3681005099656073736f48e17371 +size 1389769 diff --git a/DN_RGB/experiment/test/results-Urban100/img046_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img046_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..563faebfd00aa7ab296023db1e8efd3b4bc90605 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img046_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img047_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img047_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..59f29a6d85b339c36bf69e68369ceb0c7363f568 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img047_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:937413d634b26fc98d0073d0dccdd8f21bdc8269d0cbfd24588bb683710234c6 +size 1105597 diff --git a/DN_RGB/experiment/test/results-Urban100/img048_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img048_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..20172e0b4fb48580972049700c274e4f3d65963c --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img048_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:66e3ff06211a7441d98ab2f8ba678ab1d92b624d2accd1a6ca6b3272bc6818ef +size 1065778 diff --git a/DN_RGB/experiment/test/results-Urban100/img049_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img049_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..f9c721717e9ab1cce2ed2c6253eeb0adb2a6df09 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img049_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0364cacda9cb606dd293d2d26dcb817b7eec544a399ad66483ac9a3163da3089 +size 1099802 diff --git a/DN_RGB/experiment/test/results-Urban100/img050_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img050_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..32436722749911000427162e992bd5163cd85818 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img050_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img051_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img051_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..7f3842ee03b4b813ed00a029ee3d70e9540c4f92 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img051_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img052_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img052_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..f984b53c4d953e1c6bafd699a3fa2be5388d12cf Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img052_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img053_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img053_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..5b81ce725accfd17b1ee6572dfd040d5bf350dda --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img053_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d56aea29c83e001f262bd1166c933600a539eb235c420f5ec94d12cee134adb5 +size 1038504 diff --git a/DN_RGB/experiment/test/results-Urban100/img054_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img054_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..e96bef36cdf6b091ab4b6282ac3ae54e29977bb6 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img054_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5672754e8537ad0ad948040fdc01bbf386e8b91b869bb9efb3c8c653a057a596 +size 1162412 diff --git a/DN_RGB/experiment/test/results-Urban100/img055_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img055_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..8bee6585106515daffb81f821f63891c003d1d79 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img055_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img056_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img056_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..ba1bbeef66410bb1c81f0cb817e98dda3d241ddf --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img056_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:641d2d2e83df4e245c4407c54b450fe48aee367130ea22eedb73008ad1e5c6d0 +size 1196838 diff --git a/DN_RGB/experiment/test/results-Urban100/img057_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img057_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..6ff0d8b392a3907d34bb802064f3780da880a150 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img057_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img058_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img058_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..e25fcc037e6b0e6ad024b02f95c4bd187f826146 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img058_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0d2ece3d2f53205b41d04d04f7881134780da2b5f33b7616fdc17cc362b1bdaf +size 1128526 diff --git a/DN_RGB/experiment/test/results-Urban100/img059_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img059_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..0751645c464b764e2c278d90c1bffec5973002f0 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img059_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img060_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img060_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..bcfed5dcb5e0eb8c8caff33ce841cbe6e7062a94 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img060_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4e48cda7edbcb169e873bfde60fecadd4e7a364f518144efc3d8228c03b6733a +size 1245938 diff --git a/DN_RGB/experiment/test/results-Urban100/img061_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img061_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..950b866fbfacff337a53a0cb26c42df54d5e5ae6 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img061_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4f80513a90300a08a1769f6acc361f4819008cce08651cc2ff5e3681f76a0c09 +size 1089042 diff --git a/DN_RGB/experiment/test/results-Urban100/img062_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img062_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..3e3f044f632a3e0410ddfae9cd7d1473539e2892 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img062_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:95ff990268473a6ff80cbfab64bfc01c90d22238984d180e027ba4abc7e2dc26 +size 1049240 diff --git a/DN_RGB/experiment/test/results-Urban100/img063_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img063_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..fd3b0496ab05ca2accfd442b3aff269ebb7c73fa --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img063_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:16ce7d5500a972483de1901828d2c99a492487906e59151ea477a4947a979a02 +size 1637472 diff --git a/DN_RGB/experiment/test/results-Urban100/img064_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img064_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..aa17bc59bab2a301a3b5569d9de018027b151747 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img064_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img065_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img065_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..84a48db6972091ffa4ab9565950d563eff0325c1 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img065_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img066_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img066_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..3194f5744e32d5e15072c47cb2159769dad3cab1 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img066_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3911662460856c7560c93d6496eb17fe532978ba398c04420bfdd2cd8509fab4 +size 1293940 diff --git a/DN_RGB/experiment/test/results-Urban100/img067_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img067_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..ff105084a7196acedeb99fc80a7c7363b11c6470 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img067_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img068_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img068_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..ab5360daf841ee40309204d00ed32982a92bf8ce --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img068_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b7af9472141bd979072631b3935d5f1ab714d6a96c9a35827a3234903714a97d +size 1478362 diff --git a/DN_RGB/experiment/test/results-Urban100/img069_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img069_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..68380733c780fb7224fbb8f845329fb5b51eed7d --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img069_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7d8ffa96a186c00d94d26c8faed7054cf61880ea4ec9fbe6fe08cdff86305c51 +size 1496966 diff --git a/DN_RGB/experiment/test/results-Urban100/img070_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img070_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..aaa729ec73e666f38aa2c45c86fc5f7089b26c23 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img070_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f7c04af9159bbeb53e5d7e0a1e27ed3798fd7657922ffaa10e87da2947139da4 +size 1268486 diff --git a/DN_RGB/experiment/test/results-Urban100/img071_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img071_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..3c13959d0abf74ca7069b1a3d81992225c1a8622 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img071_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img072_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img072_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..3104dbdbe675f380712527eedc255a4a9c4a9890 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img072_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a67ac8c86e2a8db23fdb40d6f0cfb629a499e6d3b845dcf8268e169a3b289a8c +size 1286354 diff --git a/DN_RGB/experiment/test/results-Urban100/img073_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img073_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..c629bfd2c4dd3ad64b0f51cd5ecc7de3d6351b3c --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img073_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ef657ac9093493b32c6d68ff4db0c5357855522cec9a4989c4e2d9929bec659e +size 1466484 diff --git a/DN_RGB/experiment/test/results-Urban100/img074_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img074_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..f1c181ae2eac747d39c4e2a350a28830df681696 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img074_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9d6ad49dd707c4f9de8be3c042ccb08700c52d5023c4811a7938eb8eded48fdc +size 1048541 diff --git a/DN_RGB/experiment/test/results-Urban100/img075_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img075_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..e3d864a706628240237048a81f1ab4941226932f Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img075_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img076_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img076_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..6ddcce9f78ae5a62888cad330d2ee110d1032dda --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img076_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dfa4d18305ea9712cb8b7903a5199d13abb2e9c609474763e159a1a6e6580e76 +size 1052385 diff --git a/DN_RGB/experiment/test/results-Urban100/img077_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img077_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..ec9a6612319994194477280ed832a8f931631e72 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img077_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ef81c55e58fe1cc7039915190d37b4a0315e5c4b9077f5aa53c8652c269a8d7d +size 1098191 diff --git a/DN_RGB/experiment/test/results-Urban100/img078_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img078_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..be2a2bb22306684e397e0dc1d29b9b0faea6f7dc Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img078_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img079_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img079_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..51b8338355b35da544d5c8d8a485ec8b257691f4 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img079_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:de05ca7577ff14704bed29c68e73c8854beca7ae3ecc2abe950d1601bd47817a +size 1007928 diff --git a/DN_RGB/experiment/test/results-Urban100/img080_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img080_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..e390b6e95b4e4bcf2c42b7ca5e04dfd38871c636 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img080_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img081_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img081_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..430c9df1e624ac68633dae14e1d8673bde9940a3 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img081_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:33f186dcbdbe65301ece753d80c1378ae432dda04f59b66f9110b04b4006d0a2 +size 1207537 diff --git a/DN_RGB/experiment/test/results-Urban100/img082_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img082_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..eadbed6fc9ab30a8fa304180216958f6327df950 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img082_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e7f6fceb4e96ea8cca5c565cbb62f89b78897c135df0d2d6d1a2ba0efdf4e927 +size 1119292 diff --git a/DN_RGB/experiment/test/results-Urban100/img083_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img083_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..a9d2a3e581aba1312f2244a8806094e7089d213b --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img083_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dfb146ae2931bc1d37aa13544f4bec77f1a462d14605e9f491af388b6f301951 +size 1663473 diff --git a/DN_RGB/experiment/test/results-Urban100/img084_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img084_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..f99f07e2c83ad26fa56ac4e7d2dc8c084e4cc6a9 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img084_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:47de3beb27ec34ef695cf7cc0248c062821dc2f2f77d58a5f97554ebee7a4caa +size 1374742 diff --git a/DN_RGB/experiment/test/results-Urban100/img085_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img085_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..c28796fce214788cc4661b3704ff11e00f90e9fb Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img085_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img086_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img086_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..d7c913d2baf8fe828d07dbe2115ad0ee09ebe07c Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img086_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img087_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img087_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..59e8add205c97dbd275d64d74e5ea829918c5602 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img087_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:30c4d53b7534716dfb1fb93c2895df322a341a699222e21914f43ff61af65549 +size 1171503 diff --git a/DN_RGB/experiment/test/results-Urban100/img088_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img088_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..6090e6279156459ffcc51c0168217292ca2f64c4 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img088_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0ce257d55aaa9802873602bc650c051a7b3f1b830a5da92fda629f55a2d369d1 +size 1293360 diff --git a/DN_RGB/experiment/test/results-Urban100/img089_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img089_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..bf7c81342d87ed74a759c4820eea321aea232847 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img089_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c52217e47f4347da44f2ac620e70c7fddd60798fa57c051bc472f54576a27762 +size 1095215 diff --git a/DN_RGB/experiment/test/results-Urban100/img090_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img090_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..bc0a869d253604b5107084bfc554685cb9efd78b Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img090_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img091_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img091_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..2647fae61542bb19b8c0c61fb6d090058fc2f2aa --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img091_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6869c2413a0e4e17e3ad5a78f29a1e1673f14bb7fd264d70311dc9e499310d15 +size 1178382 diff --git a/DN_RGB/experiment/test/results-Urban100/img092_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img092_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..f2e8fbf02944c36ab79e942c3237b5b548df14ca --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img092_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c22726684fe2c37723372ce0f568c26d2f81ba57b07676dc4ed752c7776ccb72 +size 1351625 diff --git a/DN_RGB/experiment/test/results-Urban100/img093_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img093_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..6d461fa58291603046e99826bb91962b287bcbea Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img093_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img094_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img094_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..ee3e6034a2336432e406f6c821ec3e309fa104b2 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img094_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img095_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img095_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..565cbedea31b0a98dac5a8a5963da80285fd2c38 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img095_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:163b7ccc0a9c0ffbd59ec4da48b979cc9b6b68ff1db437326e237596cda93c73 +size 1634549 diff --git a/DN_RGB/experiment/test/results-Urban100/img096_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img096_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..16a9186718f1ba84eb0e7fe4bf586d206a32c13d Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img096_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img097_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img097_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..623bd5795023c39df2e3402c85840183ebdc0891 Binary files /dev/null and b/DN_RGB/experiment/test/results-Urban100/img097_x50_DN.png differ diff --git a/DN_RGB/experiment/test/results-Urban100/img098_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img098_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..3a79b8e16fb01106a2aeac1601afec5486744d5c --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img098_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:01a10795e6b1f3ca3d7d751af477b4af72b408ec320975bdea9cd446949dc1a4 +size 1460823 diff --git a/DN_RGB/experiment/test/results-Urban100/img099_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img099_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..5a60e0b7b203c94554532c2a1fd53c3286578a0b --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img099_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:93582319be063f9802b4e67e6d9823e6fd014fd922fffb8bd00f3a6d3015e3db +size 1138541 diff --git a/DN_RGB/experiment/test/results-Urban100/img100_x50_DN.png b/DN_RGB/experiment/test/results-Urban100/img100_x50_DN.png new file mode 100644 index 0000000000000000000000000000000000000000..4a10edd43f2bf29cb45dd7bce09e5cd0852da162 --- /dev/null +++ b/DN_RGB/experiment/test/results-Urban100/img100_x50_DN.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:471e5ac6793b84bb9d595231fb511cfff0fd9b55425903e6ebf27c407e42a4b1 +size 1880924