diff --git a/.gitattributes b/.gitattributes index a6344aac8c09253b3b630fb776ae94478aa0275b..d72ec3b48189ade970e0408eda710636803e8798 100644 --- a/.gitattributes +++ b/.gitattributes @@ -33,3 +33,71 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text *.zip filter=lfs diff=lfs merge=lfs -text *.zst filter=lfs diff=lfs merge=lfs -text *tfevents* filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000031.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000041.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000051.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000071.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000091.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004091.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000001.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000011.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000021.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000031.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000041.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000051.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000061.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000071.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000081.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000091.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000007.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000017.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000037.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000047.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000057.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000067.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000077.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000087.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000097.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000007.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000017.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000027.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000037.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000047.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000057.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000067.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000077.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000010.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000020.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000040.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000050.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000060.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000070.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000080.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000100.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000040.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000050.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000060.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000070.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000100.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000020.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000030.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000040.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000050.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000060.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000070.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000080.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000001.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000011.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000021.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000031.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000041.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000051.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000061.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000071.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000081.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000091.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000067.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000047.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000077.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000010.png filter=lfs diff=lfs merge=lfs -text +backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000020.png filter=lfs diff=lfs merge=lfs -text diff --git a/backup/bin/psrun2 b/backup/bin/psrun2 new file mode 100644 index 0000000000000000000000000000000000000000..5839889453656b5c7a6925f6253cddc449b5d6fe --- /dev/null +++ b/backup/bin/psrun2 @@ -0,0 +1,9 @@ +#!/bin/sh + +while true; do +date +#srun -p gpu_24h --gres=gpu:2 -c 20 --exclude=gpu42 --pty bash +srun -p gpu_24h --gres=gpu:2 -c 20 --constraint="rtx2080|titanv" --pty bash +#echo 1 +sleep 5 +done diff --git a/backup/bin/psrun4 b/backup/bin/psrun4 new file mode 100644 index 0000000000000000000000000000000000000000..d89918e61903e8eaf07de58b5564495f2dd9c417 --- /dev/null +++ b/backup/bin/psrun4 @@ -0,0 +1,9 @@ +#!/bin/sh + +while true; do +date +#srun -p gpu_24h --gres=gpu:4 -c 40 --exclude=gpu42 --pty bash +srun -p gpu_24h --gres=gpu:4 -c 40 --constraint="rtx2080|titanv" --pty bash +#echo 1 +sleep 15 +done diff --git a/backup/deblur/.gitignore b/backup/deblur/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..2bd8e56b4560f6914cd14db7863e0d9548b8a90c --- /dev/null +++ b/backup/deblur/.gitignore @@ -0,0 +1,109 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +env/ +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# dotenv +.env + +# virtualenv +.venv +venv/ +ENV/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ + +experiment +*.vscode +*.pt + +src/test_ssim.py + +*.sh diff --git a/backup/deblur/DeepDeblur-PyTorch/.gitignore b/backup/deblur/DeepDeblur-PyTorch/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..61b9289bde5e5de0a50db6f05879370efde03a1d --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/.gitignore @@ -0,0 +1,109 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +env/ +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# dotenv +.env + +# virtualenv +.venv +venv/ +ENV/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ + +experiment +*.vscode +*.pt + +src/test_ssim.py + +*.sh diff --git a/backup/deblur/DeepDeblur-PyTorch/LICENSE b/backup/deblur/DeepDeblur-PyTorch/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..3d27b685caad07cbad613f943ff3550e78e5e36c --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 Seungjun Nah + +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/backup/deblur/DeepDeblur-PyTorch/README.md b/backup/deblur/DeepDeblur-PyTorch/README.md new file mode 100644 index 0000000000000000000000000000000000000000..faf652a26a911c0bb4498b4fe360d0a9ed1790b8 --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/README.md @@ -0,0 +1,216 @@ +# DeepDeblur-PyTorch + +This is a pytorch implementation of our research. Please refer to our CVPR 2017 paper for details: + +Deep Multi-scale Convolutional Neural Network for Dynamic Scene Deblurring +[[paper](http://openaccess.thecvf.com/content_cvpr_2017/papers/Nah_Deep_Multi-Scale_Convolutional_CVPR_2017_paper.pdf)] +[[supplementary](http://openaccess.thecvf.com/content_cvpr_2017/supplemental/Nah_Deep_Multi-Scale_Convolutional_2017_CVPR_supplemental.zip)] +[[slide](https://drive.google.com/file/d/1sj7l2tGgJR-8wTyauvnSDGpiokjOzX_C/view?usp=sharing)] + +If you find our work useful in your research or publication, please cite our work: +``` +@InProceedings{Nah_2017_CVPR, + author = {Nah, Seungjun and Kim, Tae Hyun and Lee, Kyoung Mu}, + title = {Deep Multi-Scale Convolutional Neural Network for Dynamic Scene Deblurring}, + booktitle = {The IEEE Conference on Computer Vision and Pattern Recognition (CVPR)}, + month = {July}, + year = {2017} +} +``` + +Original Torch7 implementaion is available [here](https://github.com/SeungjunNah/DeepDeblur_release). + +## Dependencies + +* python 3 (tested with anaconda3) +* PyTorch 1.6 +* tqdm +* imageio +* scikit-image +* numpy +* matplotlib +* readline + +Please refer to [this issue](https://github.com/SeungjunNah/DeepDeblur-PyTorch/issues/5#issuecomment-651177352) for the versions. + +## Datasets + +* GOPRO_Large: [link](https://seungjunnah.github.io/Datasets/gopro) +* REDS: [link](https://seungjunnah.github.io/Datasets/reds) + +## Usage examples + +* Preparing dataset + +Before running the code, put the datasets on a desired directory. By default, the data root is set as '~/Research/dataset' +See: [src/option.py](src/option.py) +```python +group_data.add_argument('--data_root', type=str, default='~/Research/dataset', help='dataset root location') +``` +Put your dataset under ```args.data_root```. + +The dataset location should be like: +```bash +# GOPRO_Large dataset +~/Research/dataset/GOPRO_Large/train/GOPR0372_07_00/blur_gamma/.... +# REDS dataset +~/Research/dataset/REDS/train/train_blur/000/... +``` + +* Example commands + +```bash +# single GPU training +python main.py --n_GPUs 1 --batch_size 8 # save the results in default experiment/YYYY-MM-DD_hh-mm-ss +python main.py --n_GPUs 1 --batch_size 8 --save_dir GOPRO_L1 # save the results in experiment/GOPRO_L1 + +# adversarial training +python main.py --n_GPUs 1 --batch_size 8 --loss 1*L1+1*ADV +python main.py --n_GPUs 1 --batch_size 8 --loss 1*L1+3*ADV +python main.py --n_GPUs 1 --batch_size 8 --loss 1*L1+0.1*ADV + +# train with GOPRO_Large dataset +python main.py --n_GPUs 1 --batch_size 8 --dataset GOPRO_Large +# train with REDS dataset (always set --do_test false) +python main.py --n_GPUs 1 --batch_size 8 --dataset REDS --do_test false --milestones 100 150 180 --end_epoch 200 + +# save part of the evaluation results (default) +python main.py --n_GPUs 1 --batch_size 8 --dataset GOPRO_Large --save_results part +# save no evaluation results (faster at test time) +python main.py --n_GPUs 1 --batch_size 8 --dataset GOPRO_Large --save_results none +# save all of the evaluation results +python main.py --n_GPUs 1 --batch_size 8 --dataset GOPRO_Large --save_results all +``` + +```bash +# multi-GPU training (DataParallel) +python main.py --n_GPUs 2 --batch_size 16 +``` + +```bash +# multi-GPU training (DistributedDataParallel), recommended for the best speed +# single command version (do not set ranks) +python launch.py --n_GPUs 2 main.py --batch_size 16 + +# multi-command version (type in independent shells with the corresponding ranks, useful for debugging) +python main.py --batch_size 16 --distributed true --n_GPUs 2 --rank 0 # shell 0 +python main.py --batch_size 16 --distributed true --n_GPUs 2 --rank 1 # shell 1 +``` + +```bash +# single precision inference (default) +python launch.py --n_GPUs 2 main.py --batch_size 16 --precision single + +# half precision inference (faster and requires less memory) +python launch.py --n_GPUs 2 main.py --batch_size 16 --precision half + +# half precision inference with AMP +python launch.py --n_GPUs 2 main.py --batch_size 16 --amp true +``` + +```bash +# optional mixed-precision training +# mixed precision training may result in different accuracy +python main.py --n_GPUs 1 --batch_size 16 --amp true +python main.py --n_GPUs 2 --batch_size 16 --amp true +python launch.py --n_GPUs 2 main.py --batch_size 16 --amp true +``` + +```bash +# Advanced usage examples +# using launch.py is recommended for the best speed and convenience +python launch.py --n_GPUs 4 main.py --dataset GOPRO_Large +python launch.py --n_GPUs 4 main.py --dataset GOPRO_Large --milestones 500 750 900 --end_epoch 1000 --save_results none +python launch.py --n_GPUs 4 main.py --dataset GOPRO_Large --milestones 500 750 900 --end_epoch 1000 --save_results part +python launch.py --n_GPUs 4 main.py --dataset GOPRO_Large --milestones 500 750 900 --end_epoch 1000 --save_results all +python launch.py --n_GPUs 4 main.py --dataset GOPRO_Large --milestones 500 750 900 --end_epoch 1000 --save_results all --amp true + +python launch.py --n_GPUs 4 main.py --dataset REDS --milestones 100 150 180 --end_epoch 200 --save_results all --do_test false +python launch.py --n_GPUs 4 main.py --dataset REDS --milestones 100 150 180 --end_epoch 200 --save_results all --do_test false --do_validate false +``` + +```bash +# Commands used to generate the below results +python launch.py --n_GPUs 2 main.py --dataset GOPRO_Large --milestones 500 750 900 --end_epoch 1000 +python launch.py --n_GPUs 4 main.py --dataset REDS --milestones 100 150 180 --end_epoch 200 --do_test false +``` + +For more advanced usage, please take a look at src/option.py + +## Results + +* Single-precision training results + +Dataset | GOPRO_Large | REDS +:--:|:--:|:--: +PSNR | 30.40 | 32.89 +SSIM | 0.9018 | 0.9207 +Download | [link](https://drive.google.com/file/d/1-wGC6s2D2ba-PSV60AeHf48HtYd9JkQ4/view?usp=sharing) | [link](https://drive.google.com/file/d/1aSPgVsNcPNqeGPn0Y2uGmgIwaIn5Njkv/view?usp=sharing) + +* Mixed-precision training results + +Dataset | GOPRO_Large | REDS | REDS (GOPRO_Large pretrained) +:--:|:--:|:--:|:--: +PSNR| 30.42 | 32.95 | 33.13 +SSIM| 0.9021 | 0.9209 | 0.9237 +Download | [link](https://drive.google.com/file/d/1TgiiiB-4lwWIIy8c-oSSkIy5g4GvDBKB/view?usp=sharing) | [link](https://drive.google.com/file/d/10hH5vtfGUUpy8jLvIBRCBqRoEhWRO1va/view?usp=sharing) | [link](https://drive.google.com/file/d/1YV6uhGLDBbvaiWN2_cYgUhYakmvLMAM9/view?usp=sharing) + +Mixed-precision training uses less memory and is faster, especially on NVIDIA Turing-generation GPUs. +Loss scaling technique is adopted to cope with the narrow representation range of fp16. +This could improve/degrade accuracy. + +* Inference speed on RTX 2080 Ti (resolution: 1280x720) + +Inference in half precision has negligible effect on accuracy while it requires less memory and computation time. +type | FP32 | FP16 +:--:|:--:|:--: +fps | 1.06 | 3.03 +time (s) | 0.943 | 0.330 + +## Demo + +To use the trained models, download files, unzip, and put them under DeepDeblur-PyTorch/experiment +* [GOPRO_L1](https://drive.google.com/file/d/1AfZhyUXEA8_UdZco9EdtpWjTBAb8BbWv/view?usp=sharing) +* [REDS_L1](https://drive.google.com/file/d/1UwFNXnGBz2rCBxhvq2gKt9Uhj5FeEsa4/view?usp=sharing) +* [GOPRO_L1_amp](https://drive.google.com/file/d/1ZcP3l2ZXj-C6yrDge5d3UxcaAKRN725w/view?usp=sharing) +* [REDS_L1_amp](https://drive.google.com/file/d/1do_HOjVFj2AYTX4BbwQ0enELRWtzhW6F/view?usp=sharing) +* [REDS_L1_amp_pretrained](https://drive.google.com/file/d/1BkEgUrFtOSymVnaADfptOvqfNOYiD3J1/view?usp=sharing) + +```bash +python main.py --save_dir SAVE_DIR --demo true --demo_input_dir INPUT_DIR_NAME --demo_output_dir OUTPUT_DIR_NAME +# SAVE_DIR is the experiment directory where the parameters are saved (GOPRO_L1, REDS_L1) +# SAVE_DIR is relative to DeepDeblur-PyTorch/experiment +# demo_output_dir is by default SAVE_DIR/results +# image dataloader looks into DEMO_INPUT_DIR, recursively + +# example +# single GPU (GOPRO_Large, single precision) +python main.py --save_dir GOPRO_L1 --demo true --demo_input_dir ~/Research/dataset/GOPRO_Large/test/GOPR0384_11_00/blur_gamma +# single GPU (GOPRO_Large, amp-trained model, half precision) +python main.py --save_dir GOPRO_L1_amp --demo true --demo_input_dir ~/Research/dataset/GOPRO_Large/test/GOPR0384_11_00/blur_gamma --precision half +# multi-GPU (REDS, single precision) +python launch.py --n_GPUs 2 main.py --save_dir REDS_L1 --demo true --demo_input_dir ~/Research/dataset/REDS/test/test_blur --demo_output_dir OUTPUT_DIR_NAME +# multi-GPU (REDS, half precision) +python launch.py --n_GPUs 2 main.py --save_dir REDS_L1 --demo true --demo_input_dir ~/Research/dataset/REDS/test/test_blur --demo_output_dir OUTPUT_DIR_NAME --precision half +``` + +## Differences from the original code + +The default options are different from the original paper. +* RGB range is [0, 255] +* L1 loss (without adversarial loss. Usage possible. See above examples) +* Batch size increased to 16. +* Distributed multi-gpu training is recommended. +* Mixed-precision training enabled. Accuracy not guaranteed. +* SSIM function changed from MATLAB to python + +## SSIM issue + +There are many different SSIM implementations. +In this repository, SSIM metric is based on the following function: +```python +from skimage.metrics import structural_similarity +ssim = structural_similarity(ref_im, res_im, multichannel=True, gaussian_weights=True, use_sample_covariance=False) +``` +`SSIM` class in [src/loss/metric.py](src/loss/metric.py) supports PyTorch. +SSIM function in MATLAB is not correct if applied to RGB images. See [this issue](https://github.com/SeungjunNah/DeepDeblur_release/issues/51) for details. diff --git a/backup/deblur/DeepDeblur-PyTorch/experiment/.gitignore b/backup/deblur/DeepDeblur-PyTorch/experiment/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..f935021a8f8a7bd22f9d6703cafa5134bb6a57f8 --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/experiment/.gitignore @@ -0,0 +1 @@ +!.gitignore diff --git a/backup/deblur/DeepDeblur-PyTorch/src/__pycache__/option.cpython-37.pyc b/backup/deblur/DeepDeblur-PyTorch/src/__pycache__/option.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7932735ebe21a7f6438346dbdbb6982e02b1a7ca Binary files /dev/null and b/backup/deblur/DeepDeblur-PyTorch/src/__pycache__/option.cpython-37.pyc differ diff --git a/backup/deblur/DeepDeblur-PyTorch/src/__pycache__/template.cpython-37.pyc b/backup/deblur/DeepDeblur-PyTorch/src/__pycache__/template.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d4dd233320d23b725f0ec282a5b62684c530b965 Binary files /dev/null and b/backup/deblur/DeepDeblur-PyTorch/src/__pycache__/template.cpython-37.pyc differ diff --git a/backup/deblur/DeepDeblur-PyTorch/src/__pycache__/train.cpython-37.pyc b/backup/deblur/DeepDeblur-PyTorch/src/__pycache__/train.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..70daf36c556b45dc2e65bee4f4ac246722a22316 Binary files /dev/null and b/backup/deblur/DeepDeblur-PyTorch/src/__pycache__/train.cpython-37.pyc differ diff --git a/backup/deblur/DeepDeblur-PyTorch/src/__pycache__/utils.cpython-37.pyc b/backup/deblur/DeepDeblur-PyTorch/src/__pycache__/utils.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f74ec540d439f34ff6b4cabda8cd1d62c82d4b53 Binary files /dev/null and b/backup/deblur/DeepDeblur-PyTorch/src/__pycache__/utils.cpython-37.pyc differ diff --git a/backup/deblur/DeepDeblur-PyTorch/src/data/__init__.py b/backup/deblur/DeepDeblur-PyTorch/src/data/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..02fc87d2821529eb7825b49496afa7874a7c711b --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/data/__init__.py @@ -0,0 +1,79 @@ +"""Generic dataset loader""" + +from importlib import import_module + +from torch.utils.data import DataLoader +from torch.utils.data import SequentialSampler, RandomSampler +from torch.utils.data.distributed import DistributedSampler +from .sampler import DistributedEvalSampler + +class Data(): + def __init__(self, args): + + self.modes = ['train', 'val', 'test', 'demo'] + + self.action = { + 'train': args.do_train, + 'val': args.do_validate, + 'test': args.do_test, + 'demo': args.demo + } + + self.dataset_name = { + 'train': args.data_train, + 'val': args.data_val, + 'test': args.data_test, + 'demo': 'Demo' + } + + self.args = args + + def _get_data_loader(mode='train'): + dataset_name = self.dataset_name[mode] + dataset = import_module('data.' + dataset_name.lower()) + dataset = getattr(dataset, dataset_name)(args, mode) + + if mode == 'train': + if args.distributed: + batch_size = int(args.batch_size / args.n_GPUs) # batch size per GPU (single-node training) + sampler = DistributedSampler(dataset, shuffle=True, num_replicas=args.world_size, rank=args.rank) + num_workers = int((args.num_workers + args.n_GPUs - 1) / args.n_GPUs) # num_workers per GPU (single-node training) + else: + batch_size = args.batch_size + sampler = RandomSampler(dataset, replacement=False) + num_workers = args.num_workers + drop_last = True + + elif mode in ('val', 'test', 'demo'): + if args.distributed: + batch_size = 1 # 1 image per GPU + sampler = DistributedEvalSampler(dataset, shuffle=False, num_replicas=args.world_size, rank=args.rank) + num_workers = int((args.num_workers + args.n_GPUs - 1) / args.n_GPUs) # num_workers per GPU (single-node training) + else: + batch_size = args.n_GPUs # 1 image per GPU + sampler = SequentialSampler(dataset) + num_workers = args.num_workers + drop_last = False + + loader = DataLoader( + dataset=dataset, + batch_size=batch_size, + shuffle=False, + sampler=sampler, + num_workers=num_workers, + pin_memory=True, + drop_last=drop_last, + ) + + return loader + + self.loaders = {} + for mode in self.modes: + if self.action[mode]: + self.loaders[mode] = _get_data_loader(mode) + print('===> Loading {} dataset: {}'.format(mode, self.dataset_name[mode])) + else: + self.loaders[mode] = None + + def get_loader(self): + return self.loaders diff --git a/backup/deblur/DeepDeblur-PyTorch/src/data/__pycache__/__init__.cpython-37.pyc b/backup/deblur/DeepDeblur-PyTorch/src/data/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8681fea1226aef1ab62618aaf9a44ed45069808c Binary files /dev/null and b/backup/deblur/DeepDeblur-PyTorch/src/data/__pycache__/__init__.cpython-37.pyc differ diff --git a/backup/deblur/DeepDeblur-PyTorch/src/data/__pycache__/common.cpython-37.pyc b/backup/deblur/DeepDeblur-PyTorch/src/data/__pycache__/common.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7f9f2ab47e97b396fec77935312866a788b521d6 Binary files /dev/null and b/backup/deblur/DeepDeblur-PyTorch/src/data/__pycache__/common.cpython-37.pyc differ diff --git a/backup/deblur/DeepDeblur-PyTorch/src/data/__pycache__/dataset.cpython-37.pyc b/backup/deblur/DeepDeblur-PyTorch/src/data/__pycache__/dataset.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d5fa85df7f70379d77f971baaf17ee7fbdf84ac9 Binary files /dev/null and b/backup/deblur/DeepDeblur-PyTorch/src/data/__pycache__/dataset.cpython-37.pyc differ diff --git a/backup/deblur/DeepDeblur-PyTorch/src/data/__pycache__/gopro_large.cpython-37.pyc b/backup/deblur/DeepDeblur-PyTorch/src/data/__pycache__/gopro_large.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..49d27d9ee83cfc6bc3ba1848106bcc3a0f832be7 Binary files /dev/null and b/backup/deblur/DeepDeblur-PyTorch/src/data/__pycache__/gopro_large.cpython-37.pyc differ diff --git a/backup/deblur/DeepDeblur-PyTorch/src/data/__pycache__/sampler.cpython-37.pyc b/backup/deblur/DeepDeblur-PyTorch/src/data/__pycache__/sampler.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..29f2f1b4b7734dca9f6fd8e18f8978a49ac1995a Binary files /dev/null and b/backup/deblur/DeepDeblur-PyTorch/src/data/__pycache__/sampler.cpython-37.pyc differ diff --git a/backup/deblur/DeepDeblur-PyTorch/src/data/common.py b/backup/deblur/DeepDeblur-PyTorch/src/data/common.py new file mode 100644 index 0000000000000000000000000000000000000000..d22c8130bf88905fbad0b2752a6cc469d3dc1878 --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/data/common.py @@ -0,0 +1,163 @@ +import random +import numpy as np +from skimage.color import rgb2hsv, hsv2rgb +from skimage.transform import pyramid_gaussian + +import torch + +def _apply(func, x): + + if isinstance(x, (list, tuple)): + return [_apply(func, x_i) for x_i in x] + elif isinstance(x, dict): + y = {} + for key, value in x.items(): + y[key] = _apply(func, value) + return y + else: + return func(x) + +def crop(*args, ps=256): # patch_size + # args = [input, target] + def _get_shape(*args): + if isinstance(args[0], (list, tuple)): + return _get_shape(args[0][0]) + elif isinstance(args[0], dict): + return _get_shape(list(args[0].values())[0]) + else: + return args[0].shape + + h, w, _ = _get_shape(args) + + py = random.randrange(0, h-ps+1) + px = random.randrange(0, w-ps+1) + + def _crop(img): + if img.ndim == 2: + return img[py:py+ps, px:px+ps, np.newaxis] + else: + return img[py:py+ps, px:px+ps, :] + + return _apply(_crop, args) + +def add_noise(*args, sigma_sigma=2, rgb_range=255): + + if len(args) == 1: # usually there is only a single input + args = args[0] + + sigma = np.random.normal() * sigma_sigma * rgb_range/255 + + def _add_noise(img): + noise = np.random.randn(*img.shape).astype(np.float32) * sigma + return (img + noise).clip(0, rgb_range) + + return _apply(_add_noise, args) + +def augment(*args, hflip=True, rot=True, shuffle=True, change_saturation=True, rgb_range=255): + """augmentation consistent to input and target""" + + choices = (False, True) + + hflip = hflip and random.choice(choices) + vflip = rot and random.choice(choices) + rot90 = rot and random.choice(choices) + # shuffle = shuffle + + if shuffle: + rgb_order = list(range(3)) + random.shuffle(rgb_order) + if rgb_order == list(range(3)): + shuffle = False + + if change_saturation: + amp_factor = np.random.uniform(0.5, 1.5) + + def _augment(img): + if hflip: img = img[:, ::-1, :] + if vflip: img = img[::-1, :, :] + if rot90: img = img.transpose(1, 0, 2) + if shuffle and img.ndim > 2: + if img.shape[-1] == 3: # RGB image only + img = img[..., rgb_order] + + if change_saturation: + hsv_img = rgb2hsv(img) + hsv_img[..., 1] *= amp_factor + + img = hsv2rgb(hsv_img).clip(0, 1) * rgb_range + + return img.astype(np.float32) + + return _apply(_augment, args) + +def pad(img, divisor=4, pad_width=None, negative=False): + + def _pad_numpy(img, divisor=4, pad_width=None, negative=False): + if pad_width is None: + (h, w, _) = img.shape + pad_h = -h % divisor + pad_w = -w % divisor + pad_width = ((0, pad_h), (0, pad_w), (0, 0)) + + img = np.pad(img, pad_width, mode='edge') + + return img, pad_width + + def _pad_tensor(img, divisor=4, pad_width=None, negative=False): + + n, c, h, w = img.shape + if pad_width is None: + pad_h = -h % divisor + pad_w = -w % divisor + pad_width = (0, pad_w, 0, pad_h) + else: + try: + pad_h = pad_width[0][1] + pad_w = pad_width[1][1] + if isinstance(pad_h, torch.Tensor): + pad_h = pad_h.item() + if isinstance(pad_w, torch.Tensor): + pad_w = pad_w.item() + + pad_width = (0, pad_w, 0, pad_h) + except: + pass + + if negative: + pad_width = [-val for val in pad_width] + + img = torch.nn.functional.pad(img, pad_width, 'reflect') + + return img, pad_width + + if isinstance(img, np.ndarray): + return _pad_numpy(img, divisor, pad_width, negative) + else: # torch.Tensor + return _pad_tensor(img, divisor, pad_width, negative) + +def generate_pyramid(*args, n_scales): + + def _generate_pyramid(img): + if img.dtype != np.float32: + img = img.astype(np.float32) + pyramid = list(pyramid_gaussian(img, n_scales-1, multichannel=True)) + + return pyramid + + return _apply(_generate_pyramid, args) + +def np2tensor(*args): + def _np2tensor(x): + np_transpose = np.ascontiguousarray(x.transpose(2, 0, 1)) + tensor = torch.from_numpy(np_transpose) + + return tensor + + return _apply(_np2tensor, args) + +def to(*args, device=None, dtype=torch.float): + + def _to(x): + return x.to(device=device, dtype=dtype, non_blocking=True, copy=False) + + return _apply(_to, args) diff --git a/backup/deblur/DeepDeblur-PyTorch/src/data/dataset.py b/backup/deblur/DeepDeblur-PyTorch/src/data/dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..8f61a230b531135b6f6b11212eb33e87cac8c8c6 --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/data/dataset.py @@ -0,0 +1,154 @@ +import os +import random +import imageio +import numpy as np +import torch.utils.data as data + +from data import common + +from utils import interact + +class Dataset(data.Dataset): + """Basic dataloader class + """ + def __init__(self, args, mode='train'): + super(Dataset, self).__init__() + self.args = args + self.mode = mode + + self.modes = () + self.set_modes() + self._check_mode() + + self.set_keys() + + if self.mode == 'train': + dataset = args.data_train + elif self.mode == 'val': + dataset = args.data_val + elif self.mode == 'test': + dataset = args.data_test + elif self.mode == 'demo': + pass + else: + raise NotImplementedError('not implemented for this mode: {}!'.format(self.mode)) + + if self.mode == 'demo': + self.subset_root = args.demo_input_dir + else: + self.subset_root = os.path.join(args.data_root, dataset, self.mode) + + self.blur_list = [] + self.sharp_list = [] + + self._scan() + + def set_modes(self): + self.modes = ('train', 'val', 'test', 'demo') + + def _check_mode(self): + """Should be called in the child class __init__() after super + """ + if self.mode not in self.modes: + raise NotImplementedError('mode error: not for {}'.format(self.mode)) + + return + + def set_keys(self): + self.blur_key = 'blur' # to be overwritten by child class + self.sharp_key = 'sharp' # to be overwritten by child class + + self.non_blur_keys = [] + self.non_sharp_keys = [] + + return + + def _scan(self, root=None): + """Should be called in the child class __init__() after super + """ + if root is None: + root = self.subset_root + + if self.blur_key in self.non_blur_keys: + self.non_blur_keys.remove(self.blur_key) + if self.sharp_key in self.non_sharp_keys: + self.non_sharp_keys.remove(self.sharp_key) + + def _key_check(path, true_key, false_keys): + path = os.path.join(path, '') + if path.find(true_key) >= 0: + for false_key in false_keys: + if path.find(false_key) >= 0: + return False + + return True + else: + return False + + def _get_list_by_key(root, true_key, false_keys): + data_list = [] + for sub, dirs, files in os.walk(root): + if not dirs: + file_list = [os.path.join(sub, f) for f in files] + if _key_check(sub, true_key, false_keys): + data_list += file_list + + data_list.sort() + + return data_list + + def _rectify_keys(): + self.blur_key = os.path.join(self.blur_key, '') + self.non_blur_keys = [os.path.join(non_blur_key, '') for non_blur_key in self.non_blur_keys] + self.sharp_key = os.path.join(self.sharp_key, '') + self.non_sharp_keys = [os.path.join(non_sharp_key, '') for non_sharp_key in self.non_sharp_keys] + + _rectify_keys() + + self.blur_list = _get_list_by_key(root, self.blur_key, self.non_blur_keys) + self.sharp_list = _get_list_by_key(root, self.sharp_key, self.non_sharp_keys) + + if len(self.sharp_list) > 0: + assert(len(self.blur_list) == len(self.sharp_list)) + + return + + def __getitem__(self, idx): + + blur = imageio.imread(self.blur_list[idx], pilmode='RGB') + if len(self.sharp_list) > 0: + sharp = imageio.imread(self.sharp_list[idx], pilmode='RGB') + imgs = [blur, sharp] + else: + imgs = [blur] + + pad_width = 0 # dummy value + if self.mode == 'train': + imgs = common.crop(*imgs, ps=self.args.patch_size) + if self.args.augment: + imgs = common.augment(*imgs, hflip=True, rot=True, shuffle=True, change_saturation=True, rgb_range=self.args.rgb_range) + imgs[0] = common.add_noise(imgs[0], sigma_sigma=2, rgb_range=self.args.rgb_range) + elif self.mode == 'demo': + imgs[0], pad_width = common.pad(imgs[0], divisor=2**(self.args.n_scales-1)) # pad in case of non-divisible size + else: + pass # deliver test image as is. + + if self.args.gaussian_pyramid: + imgs = common.generate_pyramid(*imgs, n_scales=self.args.n_scales) + + imgs = common.np2tensor(*imgs) + relpath = os.path.relpath(self.blur_list[idx], self.subset_root) + + blur = imgs[0] + sharp = imgs[1] if len(imgs) > 1 else False + + return blur, sharp, pad_width, idx, relpath + + def __len__(self): + return len(self.blur_list) + # return 32 + + + + + diff --git a/backup/deblur/DeepDeblur-PyTorch/src/data/demo.py b/backup/deblur/DeepDeblur-PyTorch/src/data/demo.py new file mode 100644 index 0000000000000000000000000000000000000000..96512143d4b80cf4f75898f5f9f85b37f5b2f895 --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/data/demo.py @@ -0,0 +1,22 @@ +from data.dataset import Dataset + +from utils import interact + +class Demo(Dataset): + """Demo train, test subset class + """ + def __init__(self, args, mode='demo'): + super(Demo, self).__init__(args, mode) + + def set_modes(self): + self.modes = ('demo') + + def set_keys(self): + super(Demo, self).set_keys() + self.blur_key = '' # all the files + self.non_sharp_keys = [''] # no files + + def __getitem__(self, idx): + blur, sharp, pad_width, idx, relpath = super(Demo, self).__getitem__(idx) + + return blur, sharp, pad_width, idx, relpath diff --git a/backup/deblur/DeepDeblur-PyTorch/src/data/gopro_large.py b/backup/deblur/DeepDeblur-PyTorch/src/data/gopro_large.py new file mode 100644 index 0000000000000000000000000000000000000000..794a1c9784881bbdf7ee2bf9e99c652b7719dab3 --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/data/gopro_large.py @@ -0,0 +1,23 @@ +from data.dataset import Dataset + +from utils import interact + +class GOPRO_Large(Dataset): + """GOPRO_Large train, test subset class + """ + def __init__(self, args, mode='train'): + super(GOPRO_Large, self).__init__(args, mode) + + def set_modes(self): + self.modes = ('train', 'test') + + def set_keys(self): + super(GOPRO_Large, self).set_keys() + self.blur_key = 'blur_gamma' + # self.sharp_key = 'sharp' + + def __getitem__(self, idx): + blur, sharp, pad_width, idx, relpath = super(GOPRO_Large, self).__getitem__(idx) + relpath = relpath.replace('{}/'.format(self.blur_key), '') + + return blur, sharp, pad_width, idx, relpath diff --git a/backup/deblur/DeepDeblur-PyTorch/src/data/reds.py b/backup/deblur/DeepDeblur-PyTorch/src/data/reds.py new file mode 100644 index 0000000000000000000000000000000000000000..4297701698e85e18096b50e4e6eb89c402a2f13a --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/data/reds.py @@ -0,0 +1,28 @@ +from data.dataset import Dataset + +from utils import interact + +class REDS(Dataset): + """REDS train, val, test subset class + """ + def __init__(self, args, mode='train'): + super(REDS, self).__init__(args, mode) + + def set_modes(self): + self.modes = ('train', 'val', 'test') + + def set_keys(self): + super(REDS, self).set_keys() + # self.blur_key = 'blur' + # self.sharp_key = 'sharp' + + self.non_blur_keys = ['blur', 'blur_comp', 'blur_bicubic'] + self.non_blur_keys.remove(self.blur_key) + self.non_sharp_keys = ['sharp_bicubic', 'sharp'] + self.non_sharp_keys.remove(self.sharp_key) + + def __getitem__(self, idx): + blur, sharp, pad_width, idx, relpath = super(REDS, self).__getitem__(idx) + relpath = relpath.replace('{}/{}/'.format(self.mode, self.blur_key), '') + + return blur, sharp, pad_width, idx, relpath diff --git a/backup/deblur/DeepDeblur-PyTorch/src/data/sampler.py b/backup/deblur/DeepDeblur-PyTorch/src/data/sampler.py new file mode 100644 index 0000000000000000000000000000000000000000..90fc6df3e61ce7cbcaf9b9945622ccb5ee048b7f --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/data/sampler.py @@ -0,0 +1,115 @@ +import math +import torch +from torch.utils.data import Sampler +import torch.distributed as dist + + +class DistributedEvalSampler(Sampler): + r""" + DistributedEvalSampler is different from DistributedSampler. + It does NOT add extra samples to make it evenly divisible. + DistributedEvalSampler should NOT be used for training. The distributed processes could hang forever. + See this issue for details: https://github.com/pytorch/pytorch/issues/22584 + shuffle is disabled by default + + DistributedEvalSampler is for evaluation purpose where synchronization does not happen every epoch. + Synchronization should be done outside the dataloader loop. + + Sampler that restricts data loading to a subset of the dataset. + + It is especially useful in conjunction with + :class:`torch.nn.parallel.DistributedDataParallel`. In such a case, each + process can pass a :class`~torch.utils.data.DistributedSampler` instance as a + :class:`~torch.utils.data.DataLoader` sampler, and load a subset of the + original dataset that is exclusive to it. + + .. note:: + Dataset is assumed to be of constant size. + + Arguments: + dataset: Dataset used for sampling. + num_replicas (int, optional): Number of processes participating in + distributed training. By default, :attr:`rank` is retrieved from the + current distributed group. + rank (int, optional): Rank of the current process within :attr:`num_replicas`. + By default, :attr:`rank` is retrieved from the current distributed + group. + shuffle (bool, optional): If ``True`` (default), sampler will shuffle the + indices. + seed (int, optional): random seed used to shuffle the sampler if + :attr:`shuffle=True`. This number should be identical across all + processes in the distributed group. Default: ``0``. + + .. warning:: + In distributed mode, calling the :meth`set_epoch(epoch) ` method at + the beginning of each epoch **before** creating the :class:`DataLoader` iterator + is necessary to make shuffling work properly across multiple epochs. Otherwise, + the same ordering will be always used. + + Example:: + + >>> sampler = DistributedSampler(dataset) if is_distributed else None + >>> loader = DataLoader(dataset, shuffle=(sampler is None), + ... sampler=sampler) + >>> for epoch in range(start_epoch, n_epochs): + ... if is_distributed: + ... sampler.set_epoch(epoch) + ... train(loader) + """ + + def __init__(self, dataset, num_replicas=None, rank=None, shuffle=False, seed=0): + if num_replicas is None: + if not dist.is_available(): + raise RuntimeError("Requires distributed package to be available") + num_replicas = dist.get_world_size() + if rank is None: + if not dist.is_available(): + raise RuntimeError("Requires distributed package to be available") + rank = dist.get_rank() + self.dataset = dataset + self.num_replicas = num_replicas + self.rank = rank + self.epoch = 0 + # self.num_samples = int(math.ceil(len(self.dataset) * 1.0 / self.num_replicas)) + # self.total_size = self.num_samples * self.num_replicas + self.total_size = len(self.dataset) # true value without extra samples + indices = list(range(self.total_size)) + indices = indices[self.rank:self.total_size:self.num_replicas] + self.num_samples = len(indices) # true value without extra samples + + self.shuffle = shuffle + self.seed = seed + + def __iter__(self): + if self.shuffle: + # deterministically shuffle based on epoch and seed + g = torch.Generator() + g.manual_seed(self.seed + self.epoch) + indices = torch.randperm(len(self.dataset), generator=g).tolist() + else: + indices = list(range(len(self.dataset))) + + + # # add extra samples to make it evenly divisible + # indices += indices[:(self.total_size - len(indices))] + # assert len(indices) == self.total_size + + # subsample + indices = indices[self.rank:self.total_size:self.num_replicas] + assert len(indices) == self.num_samples + + return iter(indices) + + def __len__(self): + return self.num_samples + + def set_epoch(self, epoch): + r""" + Sets the epoch for this sampler. When :attr:`shuffle=True`, this ensures all replicas + use a different random ordering for each epoch. Otherwise, the next iteration of this + sampler will yield the same ordering. + + Arguments: + epoch (int): _epoch number. + """ + self.epoch = epoch diff --git a/backup/deblur/DeepDeblur-PyTorch/src/launch.py b/backup/deblur/DeepDeblur-PyTorch/src/launch.py new file mode 100644 index 0000000000000000000000000000000000000000..ffb6b6717da2802acae17680193467d6b4d1069e --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/launch.py @@ -0,0 +1,55 @@ +""" distributed launcher adopted from torch.distributed.launch + usage example: https://github.com/facebookresearch/maskrcnn-benchmark + This enables using multiprocessing for each spawned process (as they are treated as main processes) +""" +import sys +import subprocess +from argparse import ArgumentParser, REMAINDER + +from utils import str2bool, int2str + +def parse_args(): + parser = ArgumentParser(description="PyTorch distributed training launch " + "helper utilty that will spawn up " + "multiple distributed processes") + + + parser.add_argument('--n_GPUs', type=int, default=1, help='the number of GPUs for training') + + # positional + parser.add_argument("training_script", type=str, + help="The full path to the single GPU training " + "program/script to be launched in parallel, " + "followed by all the arguments for the " + "training script") + + # rest from the training program + parser.add_argument('training_script_args', nargs=REMAINDER) + return parser.parse_args() + +def main(): + args = parse_args() + + processes = [] + for rank in range(0, args.n_GPUs): + cmd = [sys.executable] + + cmd.append(args.training_script) + cmd.extend(args.training_script_args) + + cmd += ['--distributed', 'True'] + cmd += ['--launched', 'True'] + cmd += ['--n_GPUs', str(args.n_GPUs)] + cmd += ['--rank', str(rank)] + + process = subprocess.Popen(cmd) + processes.append(process) + + for process in processes: + process.wait() + if process.returncode != 0: + raise subprocess.CalledProcessError(returncode=process.returncode, + cmd=cmd) + +if __name__ == "__main__": + main() diff --git a/backup/deblur/DeepDeblur-PyTorch/src/loss/__init__.py b/backup/deblur/DeepDeblur-PyTorch/src/loss/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..93a9f23a565c35f4a0052326350dc844977e2ac2 --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/loss/__init__.py @@ -0,0 +1,464 @@ +import os +from importlib import import_module + +import torch +from torch import nn +import torch.distributed as dist + +import matplotlib.pyplot as plt +plt.switch_backend('agg') # https://github.com/matplotlib/matplotlib/issues/3466 + +from .metric import PSNR, SSIM + +from utils import interact + +class Loss(torch.nn.modules.loss._Loss): + def __init__(self, args, epoch=None, model=None, optimizer=None): + """ + input: + args.loss use '+' to sum over different loss functions + use '*' to specify the loss weight + + example: + 1*MSE+0.5*VGG54 + loss = sum of MSE and VGG54(weight=0.5) + + args.measure similar to args.loss, but without weight + + example: + MSE+PSNR + measure MSE and PSNR, independently + """ + super(Loss, self).__init__() + + self.args = args + + self.rgb_range = args.rgb_range + self.device_type = args.device_type + self.synchronized = False + + self.epoch = args.start_epoch if epoch is None else epoch + self.save_dir = args.save_dir + self.save_name = os.path.join(self.save_dir, 'loss.pt') + + # self.training = True + self.validating = False + self.testing = False + self.mode = 'train' + self.modes = ('train', 'val', 'test') + + # Loss + self.loss = nn.ModuleDict() + self.loss_types = [] + self.weight = {} + + self.loss_stat = {mode:{} for mode in self.modes} + # loss_stat[mode][loss_type][epoch] = loss_value + # loss_stat[mode]['Total'][epoch] = loss_total + + for weighted_loss in args.loss.split('+'): + w, l = weighted_loss.split('*') + l = l.upper() + if l in ('ABS', 'L1'): + loss_type = 'L1' + func = nn.L1Loss() + elif l in ('MSE', 'L2'): + loss_type = 'L2' + func = nn.MSELoss() + elif l in ('ADV', 'GAN'): + loss_type = 'ADV' + m = import_module('loss.adversarial') + func = getattr(m, 'Adversarial')(args, model, optimizer) + else: + loss_type = l + m = import_module*'loss.{}'.format(l.lower()) + func = getattr(m, l)(args) + + self.loss_types += [loss_type] + self.loss[loss_type] = func + self.weight[loss_type] = float(w) + + print('Loss function: {}'.format(args.loss)) + + # Metrics + self.do_measure = args.metric.lower() != 'none' + + self.metric = nn.ModuleDict() + self.metric_types = [] + self.metric_stat = {mode:{} for mode in self.modes} + # metric_stat[mode][metric_type][epoch] = metric_value + + if self.do_measure: + for metric_type in args.metric.split(','): + metric_type = metric_type.upper() + if metric_type == 'PSNR': + metric_func = PSNR() + elif metric_type == 'SSIM': + metric_func = SSIM(args.device_type) # single precision + else: + raise NotImplementedError + + self.metric_types += [metric_type] + self.metric[metric_type] = metric_func + + print('Metrics: {}'.format(args.metric)) + + if args.start_epoch != 1: + self.load(args.start_epoch - 1) + + for mode in self.modes: + for loss_type in self.loss: + if loss_type not in self.loss_stat[mode]: + self.loss_stat[mode][loss_type] = {} # initialize loss + + if 'Total' not in self.loss_stat[mode]: + self.loss_stat[mode]['Total'] = {} + + if self.do_measure: + for metric_type in self.metric: + if metric_type not in self.metric_stat[mode]: + self.metric_stat[mode][metric_type] = {} + + self.count = 0 + self.count_m = 0 + + self.to(args.device, dtype=args.dtype) + + def train(self, mode=True): + super(Loss, self).train(mode) + if mode: + self.validating = False + self.testing = False + self.mode = 'train' + else: # default test mode + self.validating = False + self.testing = True + self.mode = 'test' + + def validate(self): + super(Loss, self).eval() + # self.training = False + self.validating = True + self.testing = False + self.mode = 'val' + + def test(self): + super(Loss, self).eval() + # self.training = False + self.validating = False + self.testing = True + self.mode = 'test' + + def forward(self, input, target): + self.synchronized = False + + loss = 0 + + def _ms_forward(input, target, func): + if isinstance(input, (list, tuple)): # loss for list output + _loss = [] + for (input_i, target_i) in zip(input, target): + _loss += [func(input_i, target_i)] + return sum(_loss) + elif isinstance(input, dict): # loss for dict output + _loss = [] + for key in input: + _loss += [func(input[key], target[key])] + return sum(_loss) + else: # loss for tensor output + return func(input, target) + + # initialize + if self.count == 0: + for loss_type in self.loss_types: + self.loss_stat[self.mode][loss_type][self.epoch] = 0 + self.loss_stat[self.mode]['Total'][self.epoch] = 0 + + if isinstance(input, list): + count = input[0].shape[0] + else: # Tensor + count = input.shape[0] # batch size + + isnan = False + for loss_type in self.loss_types: + + if loss_type == 'ADV': + _loss = self.loss[loss_type](input[0], target[0], self.training) * self.weight[loss_type] + else: + _loss = _ms_forward(input, target, self.loss[loss_type]) * self.weight[loss_type] + + if torch.isnan(_loss): + isnan = True # skip recording (will also be skipped at backprop) + else: + self.loss_stat[self.mode][loss_type][self.epoch] += _loss.item() * count + self.loss_stat[self.mode]['Total'][self.epoch] += _loss.item() * count + + loss += _loss + + if not isnan: + self.count += count + + if not self.training and self.do_measure: + self.measure(input, target) + + return loss + + def measure(self, input, target): + if isinstance(input, (list, tuple)): + self.measure(input[0], target[0]) + return + elif isinstance(input, dict): + first_key = list(input.keys())[0] + self.measure(input[first_key], target[first_key]) + return + else: + pass + + if self.count_m == 0: + for metric_type in self.metric_stat[self.mode]: + self.metric_stat[self.mode][metric_type][self.epoch] = 0 + + if isinstance(input, list): + count = input[0].shape[0] + else: # Tensor + count = input.shape[0] # batch size + + for metric_type in self.metric_stat[self.mode]: + + input = input.clamp(0, self.rgb_range) # not in_place + if self.rgb_range == 255: + input.round_() + + _metric = self.metric[metric_type](input, target) + self.metric_stat[self.mode][metric_type][self.epoch] += _metric.item() * count + + self.count_m += count + + return + + def normalize(self): + if self.args.distributed: + dist.barrier() + if not self.synchronized: + self.all_reduce() + + if self.count > 0: + for loss_type in self.loss_stat[self.mode]: # including 'Total' + self.loss_stat[self.mode][loss_type][self.epoch] /= self.count + self.count = 0 + + if self.count_m > 0: + for metric_type in self.metric_stat[self.mode]: + self.metric_stat[self.mode][metric_type][self.epoch] /= self.count_m + self.count_m = 0 + + return + + def all_reduce(self, epoch=None): + # synchronize loss for distributed GPU processes + + if epoch is None: + epoch = self.epoch + + def _reduce_value(value, ReduceOp=dist.ReduceOp.SUM): + value_tensor = torch.Tensor([value]).to(self.args.device, self.args.dtype, non_blocking=True) + dist.all_reduce(value_tensor, ReduceOp, async_op=False) + value = value_tensor.item() + del value_tensor + + return value + + dist.barrier() + if self.count > 0: # I assume this should be true + self.count = _reduce_value(self.count, dist.ReduceOp.SUM) + + for loss_type in self.loss_stat[self.mode]: + self.loss_stat[self.mode][loss_type][epoch] = _reduce_value( + self.loss_stat[self.mode][loss_type][epoch], + dist.ReduceOp.SUM + ) + + if self.count_m > 0: + self.count_m = _reduce_value(self.count_m, dist.ReduceOp.SUM) + + for metric_type in self.metric_stat[self.mode]: + self.metric_stat[self.mode][metric_type][epoch] = _reduce_value( + self.metric_stat[self.mode][metric_type][epoch], + dist.ReduceOp.SUM + ) + + self.synchronized = True + + return + + def print_metrics(self): + + print(self.get_metric_desc()) + return + + def get_last_loss(self): + return self.loss_stat[self.mode]['Total'][self.epoch] + + def get_loss_desc(self): + + if self.mode == 'train': + desc_prefix = 'Train' + elif self.mode == 'val': + desc_prefix = 'Validation' + else: + desc_prefix = 'Test' + + loss = self.loss_stat[self.mode]['Total'][self.epoch] + if self.count > 0: + loss /= self.count + desc = '{} Loss: {:.1f}'.format(desc_prefix, loss) + + if self.mode in ('val', 'test'): + metric_desc = self.get_metric_desc() + desc = '{}{}'.format(desc, metric_desc) + + return desc + + def get_metric_desc(self): + desc = '' + for metric_type in self.metric_stat[self.mode]: + measured = self.metric_stat[self.mode][metric_type][self.epoch] + if self.count_m > 0: + measured /= self.count_m + + if metric_type == 'PSNR': + desc += ' {}: {:2.2f}'.format(metric_type, measured) + elif metric_type == 'SSIM': + desc += ' {}: {:1.4f}'.format(metric_type, measured) + else: + desc += ' {}: {:2.4f}'.format(metric_type, measured) + + return desc + + def step(self, plot_name=None): + self.normalize() + self.plot(plot_name) + if not self.training and self.do_measure: + # self.print_metrics() + self.plot_metric() + # self.epoch += 1 + + return + + def save(self): + + state = { + 'loss_stat': self.loss_stat, + 'metric_stat': self.metric_stat, + } + torch.save(state, self.save_name) + + return + + def load(self, epoch=None): + + print('Loading loss record from {}'.format(self.save_name)) + if os.path.exists(self.save_name): + state = torch.load(self.save_name, map_location=self.args.device) + + self.loss_stat = state['loss_stat'] + if 'metric_stat' in state: + self.metric_stat = state['metric_stat'] + else: + pass + else: + print('no loss record found for {}!'.format(self.save_name)) + + if epoch is not None: + self.epoch = epoch + + return + + def plot(self, plot_name=None, metric=False): + + self.plot_loss(plot_name) + + if metric: + self.plot_metric(plot_name) + # else: + # self.plot_loss(plot_name) + + return + + + def plot_loss(self, plot_name=None): + if plot_name is None: + plot_name = os.path.join(self.save_dir, "{}_loss.pdf".format(self.mode)) + + title = "{} loss".format(self.mode) + + fig = plt.figure() + plt.title(title) + plt.xlabel('epochs') + plt.ylabel('loss') + plt.grid(True, linestyle=':') + + for loss_type, loss_record in self.loss_stat[self.mode].items(): # including Total + axis = sorted([epoch for epoch in loss_record.keys() if epoch <= self.epoch]) + value = [self.loss_stat[self.mode][loss_type][epoch] for epoch in axis] + label = loss_type + + plt.plot(axis, value, label=label) + + plt.xlim(0, self.epoch) + plt.legend() + plt.savefig(plot_name) + plt.close(fig) + + return + + def plot_metric(self, plot_name=None): + # assume there are only max 2 metrics + if plot_name is None: + plot_name = os.path.join(self.save_dir, "{}_metric.pdf".format(self.mode)) + + title = "{} metrics".format(self.mode) + + fig, ax1 = plt.subplots() + plt.title(title) + plt.grid(True, linestyle=':') + ax1.set_xlabel('epochs') + + plots = None + for metric_type, metric_record in self.metric_stat[self.mode].items(): + axis = sorted([epoch for epoch in metric_record.keys() if epoch <= self.epoch]) + value = [metric_record[epoch] for epoch in axis] + label = metric_type + + if metric_type == 'PSNR': + ax = ax1 + color='C0' + elif metric_type == 'SSIM': + ax2 = ax1.twinx() + ax = ax2 + color='C1' + + ax.set_ylabel(metric_type) + if plots is None: + plots = ax.plot(axis, value, label=label, color=color) + else: + plots += ax.plot(axis, value, label=label, color=color) + + labels = [plot.get_label() for plot in plots] + plt.legend(plots, labels) + plt.xlim(0, self.epoch) + plt.savefig(plot_name) + plt.close(fig) + + return + + def sort(self): + # sort the loss/metric record + for mode in self.modes: + for loss_type, loss_epochs in self.loss_stat[mode].items(): + self.loss_stat[mode][loss_type] = {epoch: loss_epochs[epoch] for epoch in sorted(loss_epochs)} + + for metric_type, metric_epochs in self.metric_stat[mode].items(): + self.metric_stat[mode][metric_type] = {epoch: metric_epochs[epoch] for epoch in sorted(metric_epochs)} + + return self diff --git a/backup/deblur/DeepDeblur-PyTorch/src/loss/__pycache__/__init__.cpython-37.pyc b/backup/deblur/DeepDeblur-PyTorch/src/loss/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8d35272e05542052972b3732907f191b41db9c36 Binary files /dev/null and b/backup/deblur/DeepDeblur-PyTorch/src/loss/__pycache__/__init__.cpython-37.pyc differ diff --git a/backup/deblur/DeepDeblur-PyTorch/src/loss/__pycache__/metric.cpython-37.pyc b/backup/deblur/DeepDeblur-PyTorch/src/loss/__pycache__/metric.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..136c8020a316d1c93f206967d679240b3a42d937 Binary files /dev/null and b/backup/deblur/DeepDeblur-PyTorch/src/loss/__pycache__/metric.cpython-37.pyc differ diff --git a/backup/deblur/DeepDeblur-PyTorch/src/loss/adversarial.py b/backup/deblur/DeepDeblur-PyTorch/src/loss/adversarial.py new file mode 100644 index 0000000000000000000000000000000000000000..a7de5b77b63eaf7b3ccc9cc1dbaf4546627f008a --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/loss/adversarial.py @@ -0,0 +1,52 @@ +import torch +import torch.nn as nn + +from utils import interact + +import torch.cuda.amp as amp + +class Adversarial(nn.modules.loss._Loss): + # pure loss function without saving & loading option + # but trains deiscriminator + def __init__(self, args, model, optimizer): + super(Adversarial, self).__init__() + self.args = args + self.model = model.model + self.optimizer = optimizer + self.scaler = amp.GradScaler( + init_scale=self.args.init_scale, + enabled=self.args.amp + ) + + self.gan_k = 1 + + self.BCELoss = nn.BCEWithLogitsLoss() + + def forward(self, fake, real, training=False): + if training: + # update discriminator + fake_detach = fake.detach() + for _ in range(self.gan_k): + self.optimizer.D.zero_grad() + # d: B x 1 tensor + with amp.autocast(self.args.amp): + d_fake = self.model.D(fake_detach) + d_real = self.model.D(real) + + label_fake = torch.zeros_like(d_fake) + label_real = torch.ones_like(d_real) + + loss_d = self.BCELoss(d_fake, label_fake) + self.BCELoss(d_real, label_real) + + self.scaler.scale(loss_d).backward(retain_graph=False) + self.scaler.step(self.optimizer.D) + self.scaler.update() + else: + d_real = self.model.D(real) + label_real = torch.ones_like(d_real) + + # update generator (outside here) + d_fake_bp = self.model.D(fake) + loss_g = self.BCELoss(d_fake_bp, label_real) + + return loss_g \ No newline at end of file diff --git a/backup/deblur/DeepDeblur-PyTorch/src/loss/metric.py b/backup/deblur/DeepDeblur-PyTorch/src/loss/metric.py new file mode 100644 index 0000000000000000000000000000000000000000..bdbc5f660ca04a5bfe7063fb0595ec657ba71a37 --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/loss/metric.py @@ -0,0 +1,112 @@ +# from skimage.metrics import peak_signal_noise_ratio, structural_similarity + +import torch +from torch import nn + +def _expand(img): + if img.ndim < 4: + img = img.expand([1] * (4-img.ndim) + list(img.shape)) + + return img + +class PSNR(nn.Module): + def __init__(self): + super(PSNR, self).__init__() + + def forward(self, im1, im2, data_range=None): + # tensor input, constant output + + if data_range is None: + data_range = 255 if im1.max() > 1 else 1 + + se = (im1-im2)**2 + se = _expand(se) + + mse = se.mean(dim=list(range(1, se.ndim))) + psnr = 10 * (data_range**2/mse).log10().mean() + + return psnr + +class SSIM(nn.Module): + def __init__(self, device_type='cpu', dtype=torch.float32): + super(SSIM, self).__init__() + + self.device_type = device_type + self.dtype = dtype # SSIM in half precision could be inaccurate + + def _get_ssim_weight(): + truncate = 3.5 + sigma = 1.5 + r = int(truncate * sigma + 0.5) # radius as in ndimage + win_size = 2 * r + 1 + nch = 3 + + weight = torch.Tensor([-(x - win_size//2)**2/float(2*sigma**2) for x in range(win_size)]).exp().unsqueeze(1) + weight = weight.mm(weight.t()) + weight /= weight.sum() + weight = weight.repeat(nch, 1, 1, 1) + + return weight + + self.weight = _get_ssim_weight().to(self.device_type, dtype=self.dtype, non_blocking=True) + + def forward(self, im1, im2, data_range=None): + """Implementation adopted from skimage.metrics.structural_similarity + Default arguments set to multichannel=True, gaussian_weight=True, use_sample_covariance=False + """ + + im1 = im1.to(self.device_type, dtype=self.dtype, non_blocking=True) + im2 = im2.to(self.device_type, dtype=self.dtype, non_blocking=True) + + K1 = 0.01 + K2 = 0.03 + sigma = 1.5 + + truncate = 3.5 + r = int(truncate * sigma + 0.5) # radius as in ndimage + win_size = 2 * r + 1 + + im1 = _expand(im1) + im2 = _expand(im2) + + nch = im1.shape[1] + + if im1.shape[2] < win_size or im1.shape[3] < win_size: + raise ValueError( + "win_size exceeds image extent. If the input is a multichannel " + "(color) image, set multichannel=True.") + + if data_range is None: + data_range = 255 if im1.max() > 1 else 1 + + def filter_func(img): # no padding + return nn.functional.conv2d(img, self.weight, groups=nch).to(self.dtype) + # return torch.conv2d(img, self.weight, groups=nch).to(self.dtype) + + # compute (weighted) means + ux = filter_func(im1) + uy = filter_func(im2) + + # compute (weighted) variances and covariances + uxx = filter_func(im1 * im1) + uyy = filter_func(im2 * im2) + uxy = filter_func(im1 * im2) + vx = (uxx - ux * ux) + vy = (uyy - uy * uy) + vxy = (uxy - ux * uy) + + R = data_range + C1 = (K1 * R) ** 2 + C2 = (K2 * R) ** 2 + + A1, A2, B1, B2 = ((2 * ux * uy + C1, + 2 * vxy + C2, + ux ** 2 + uy ** 2 + C1, + vx + vy + C2)) + D = B1 * B2 + S = (A1 * A2) / D + + # compute (weighted) mean of ssim + mssim = S.mean() + + return mssim diff --git a/backup/deblur/DeepDeblur-PyTorch/src/main.py b/backup/deblur/DeepDeblur-PyTorch/src/main.py new file mode 100644 index 0000000000000000000000000000000000000000..8711b254d335ef26358bd820d05ae589b7d712a3 --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/main.py @@ -0,0 +1,67 @@ +"""main file that does everything""" +from utils import interact + +from option import args, setup, cleanup +from data import Data +from model import Model +from loss import Loss +from optim import Optimizer +from train import Trainer + +def main_worker(rank, args): + args.rank = rank + args = setup(args) + + loaders = Data(args).get_loader() + model = Model(args) + model.parallelize() + optimizer = Optimizer(args, model) + + criterion = Loss(args, model=model, optimizer=optimizer) + + trainer = Trainer(args, model, criterion, optimizer, loaders) + + if args.stay: + interact(local=locals()) + exit() + + if args.demo: + trainer.evaluate(epoch=args.start_epoch, mode='demo') + exit() + + for epoch in range(1, args.start_epoch): + if args.do_validate: + if epoch % args.validate_every == 0: + trainer.fill_evaluation(epoch, 'val') + if args.do_test: + if epoch % args.test_every == 0: + trainer.fill_evaluation(epoch, 'test') + + for epoch in range(args.start_epoch, args.end_epoch+1): + if args.do_train: + trainer.train(epoch) + + if args.do_validate: + if epoch % args.validate_every == 0: + if trainer.epoch != epoch: + trainer.load(epoch) + trainer.validate(epoch) + + if args.do_test: + if epoch % args.test_every == 0: + if trainer.epoch != epoch: + trainer.load(epoch) + trainer.test(epoch) + + if args.rank == 0 or not args.launched: + print('') + + trainer.imsaver.join_background() + + cleanup(args) + +def main(): + main_worker(args.rank, args) + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/backup/deblur/DeepDeblur-PyTorch/src/model/MSResNet.py b/backup/deblur/DeepDeblur-PyTorch/src/model/MSResNet.py new file mode 100644 index 0000000000000000000000000000000000000000..fd6c9aab0303182f55ddac0f05bb53b5673fe667 --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/model/MSResNet.py @@ -0,0 +1,67 @@ +import torch +import torch.nn as nn + +from . import common +from .ResNet import ResNet + + +def build_model(args): + return MSResNet(args) + +class conv_end(nn.Module): + def __init__(self, in_channels=3, out_channels=3, kernel_size=5, ratio=2): + super(conv_end, self).__init__() + + modules = [ + common.default_conv(in_channels, out_channels, kernel_size), + nn.PixelShuffle(ratio) + ] + + self.uppath = nn.Sequential(*modules) + + def forward(self, x): + return self.uppath(x) + +class MSResNet(nn.Module): + def __init__(self, args): + super(MSResNet, self).__init__() + + self.rgb_range = args.rgb_range + self.mean = self.rgb_range / 2 + + self.n_resblocks = args.n_resblocks + self.n_feats = args.n_feats + self.kernel_size = args.kernel_size + + self.n_scales = args.n_scales + + self.body_models = nn.ModuleList([ + ResNet(args, 3, 3, mean_shift=False), + ]) + for _ in range(1, self.n_scales): + self.body_models.insert(0, ResNet(args, 6, 3, mean_shift=False)) + + self.conv_end_models = nn.ModuleList([None]) + for _ in range(1, self.n_scales): + self.conv_end_models += [conv_end(3, 12)] + + def forward(self, input_pyramid): + + scales = range(self.n_scales-1, -1, -1) # 0: fine, 2: coarse + + for s in scales: + input_pyramid[s] = input_pyramid[s] - self.mean + + output_pyramid = [None] * self.n_scales + + input_s = input_pyramid[-1] + for s in scales: # [2, 1, 0] + output_pyramid[s] = self.body_models[s](input_s) + if s > 0: + up_feat = self.conv_end_models[s](output_pyramid[s]) + input_s = torch.cat((input_pyramid[s-1], up_feat), 1) + + for s in scales: + output_pyramid[s] = output_pyramid[s] + self.mean + + return output_pyramid diff --git a/backup/deblur/DeepDeblur-PyTorch/src/model/ResNet.py b/backup/deblur/DeepDeblur-PyTorch/src/model/ResNet.py new file mode 100644 index 0000000000000000000000000000000000000000..b950c62f86ebcd231ec4cd705e7f5a5043b85d35 --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/model/ResNet.py @@ -0,0 +1,41 @@ +import torch.nn as nn + +from . import common + +def build_model(args): + return ResNet(args) + +class ResNet(nn.Module): + def __init__(self, args, in_channels=3, out_channels=3, n_feats=None, kernel_size=None, n_resblocks=None, mean_shift=True): + super(ResNet, self).__init__() + + self.in_channels = in_channels + self.out_channels = out_channels + + self.n_feats = args.n_feats if n_feats is None else n_feats + self.kernel_size = args.kernel_size if kernel_size is None else kernel_size + self.n_resblocks = args.n_resblocks if n_resblocks is None else n_resblocks + + self.mean_shift = mean_shift + self.rgb_range = args.rgb_range + self.mean = self.rgb_range / 2 + + modules = [] + modules.append(common.default_conv(self.in_channels, self.n_feats, self.kernel_size)) + for _ in range(self.n_resblocks): + modules.append(common.ResBlock(self.n_feats, self.kernel_size)) + modules.append(common.default_conv(self.n_feats, self.out_channels, self.kernel_size)) + + self.body = nn.Sequential(*modules) + + def forward(self, input): + if self.mean_shift: + input = input - self.mean + + output = self.body(input) + + if self.mean_shift: + output = output + self.mean + + return output + diff --git a/backup/deblur/DeepDeblur-PyTorch/src/model/__init__.py b/backup/deblur/DeepDeblur-PyTorch/src/model/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..850e4847cd30be9e224f384a219ae0e7258cc71b --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/model/__init__.py @@ -0,0 +1,136 @@ +import os +import re +from importlib import import_module + +import torch +import torch.nn as nn +from torch.nn.parallel import DataParallel, DistributedDataParallel + +import torch.distributed as dist +from torch.nn.utils import parameters_to_vector, vector_to_parameters + +from .discriminator import Discriminator + +from utils import interact + +class Model(nn.Module): + def __init__(self, args): + super(Model, self).__init__() + + self.args = args + self.device = args.device + self.n_GPUs = args.n_GPUs + self.save_dir = os.path.join(args.save_dir, 'models') + os.makedirs(self.save_dir, exist_ok=True) + + module = import_module('model.' + args.model) + + self.model = nn.ModuleDict() + self.model.G = module.build_model(args) + if self.args.loss.lower().find('adv') >= 0: + self.model.D = Discriminator(self.args) + else: + self.model.D = None + + self.to(args.device, dtype=args.dtype, non_blocking=True) + self.load(args.load_epoch, path=args.pretrained) + + def parallelize(self): + if self.args.device_type == 'cuda': + if self.args.distributed: + Parallel = DistributedDataParallel + parallel_args = { + "device_ids": [self.args.rank], + "output_device": self.args.rank, + } + else: + Parallel = DataParallel + parallel_args = { + 'device_ids': list(range(self.n_GPUs)), + 'output_device': self.args.rank # always 0 + } + + for model_key in self.model: + if self.model[model_key] is not None: + self.model[model_key] = Parallel(self.model[model_key], **parallel_args) + + def forward(self, input): + return self.model.G(input) + + def _save_path(self, epoch): + model_path = os.path.join(self.save_dir, 'model-{:d}.pt'.format(epoch)) + return model_path + + def state_dict(self): + state_dict = {} + for model_key in self.model: + if self.model[model_key] is not None: + parallelized = isinstance(self.model[model_key], (DataParallel, DistributedDataParallel)) + if parallelized: + state_dict[model_key] = self.model[model_key].module.state_dict() + else: + state_dict[model_key] = self.model[model_key].state_dict() + + return state_dict + + def load_state_dict(self, state_dict, strict=True): + for model_key in self.model: + parallelized = isinstance(self.model[model_key], (DataParallel, DistributedDataParallel)) + if model_key in state_dict: + if parallelized: + self.model[model_key].module.load_state_dict(state_dict[model_key], strict) + else: + self.model[model_key].load_state_dict(state_dict[model_key], strict) + + def save(self, epoch): + torch.save(self.state_dict(), self._save_path(epoch)) + + def load(self, epoch=None, path=None): + if path: + model_name = path + elif isinstance(epoch, int): + if epoch < 0: + epoch = self.get_last_epoch() + if epoch == 0: # epoch 0 + # make sure model parameters are synchronized at initial + # for multi-node training (not in current implementation) + # self.synchronize() + + return # leave model as initialized + + model_name = self._save_path(epoch) + else: + raise Exception('no epoch number or model path specified!') + + print('Loading model from {}'.format(model_name)) + state_dict = torch.load(model_name, map_location=self.args.device) + self.load_state_dict(state_dict) + + return + + def synchronize(self): + if self.args.distributed: + # synchronize model parameters across nodes + vector = parameters_to_vector(self.parameters()) + + dist.broadcast(vector, 0) # broadcast parameters to other processes + if self.args.rank != 0: + vector_to_parameters(vector, self.parameters()) + + del vector + + return + + def get_last_epoch(self): + model_list = sorted(os.listdir(self.save_dir)) + if len(model_list) == 0: + epoch = 0 + else: + epoch = int(re.findall('\\d+', model_list[-1])[0]) # model example name model-100.pt + + return epoch + + def print(self): + print(self.model) + + return diff --git a/backup/deblur/DeepDeblur-PyTorch/src/model/__pycache__/MSResNet.cpython-37.pyc b/backup/deblur/DeepDeblur-PyTorch/src/model/__pycache__/MSResNet.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4b3f56d8905207fe407485b819fb10060e9ecd3f Binary files /dev/null and b/backup/deblur/DeepDeblur-PyTorch/src/model/__pycache__/MSResNet.cpython-37.pyc differ diff --git a/backup/deblur/DeepDeblur-PyTorch/src/model/__pycache__/ResNet.cpython-37.pyc b/backup/deblur/DeepDeblur-PyTorch/src/model/__pycache__/ResNet.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..988572fa60c64555b1cd2bedc3da455f199171d3 Binary files /dev/null and b/backup/deblur/DeepDeblur-PyTorch/src/model/__pycache__/ResNet.cpython-37.pyc differ diff --git a/backup/deblur/DeepDeblur-PyTorch/src/model/__pycache__/__init__.cpython-37.pyc b/backup/deblur/DeepDeblur-PyTorch/src/model/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e680157f12c677273370d197cba88edc554e79b8 Binary files /dev/null and b/backup/deblur/DeepDeblur-PyTorch/src/model/__pycache__/__init__.cpython-37.pyc differ diff --git a/backup/deblur/DeepDeblur-PyTorch/src/model/__pycache__/common.cpython-37.pyc b/backup/deblur/DeepDeblur-PyTorch/src/model/__pycache__/common.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..92c4ff378955a6085ad607f64d6e4128a60745b9 Binary files /dev/null and b/backup/deblur/DeepDeblur-PyTorch/src/model/__pycache__/common.cpython-37.pyc differ diff --git a/backup/deblur/DeepDeblur-PyTorch/src/model/__pycache__/discriminator.cpython-37.pyc b/backup/deblur/DeepDeblur-PyTorch/src/model/__pycache__/discriminator.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..04e3e84b14dfa451121221ac702ed96fba37c74d Binary files /dev/null and b/backup/deblur/DeepDeblur-PyTorch/src/model/__pycache__/discriminator.cpython-37.pyc differ diff --git a/backup/deblur/DeepDeblur-PyTorch/src/model/common.py b/backup/deblur/DeepDeblur-PyTorch/src/model/common.py new file mode 100644 index 0000000000000000000000000000000000000000..e10fd798dc921473b4479c5c0fa1be1532ad32bb --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/model/common.py @@ -0,0 +1,161 @@ +import math + +import torch +import torch.nn as nn + +def default_conv(in_channels, out_channels, kernel_size, bias=True, groups=1): + return nn.Conv2d( + in_channels, out_channels, kernel_size, + padding=(kernel_size // 2), bias=bias, groups=groups) + +def default_norm(n_feats): + return nn.BatchNorm2d(n_feats) + +def default_act(): + return nn.ReLU(True) + +def empty_h(x, n_feats): + ''' + create an empty hidden state + + input + x: B x T x 3 x H x W + + output + h: B x C x H/4 x W/4 + ''' + b = x.size(0) + h, w = x.size()[-2:] + return x.new_zeros((b, n_feats, h//4, w//4)) + +class Normalization(nn.Conv2d): + """Normalize input tensor value with convolutional layer""" + def __init__(self, mean=(0, 0, 0), std=(1, 1, 1)): + super(Normalization, self).__init__(3, 3, kernel_size=1) + tensor_mean = torch.Tensor(mean) + tensor_inv_std = torch.Tensor(std).reciprocal() + + self.weight.data = torch.eye(3).mul(tensor_inv_std).view(3, 3, 1, 1) + self.bias.data = torch.Tensor(-tensor_mean.mul(tensor_inv_std)) + + for params in self.parameters(): + params.requires_grad = False + +class BasicBlock(nn.Sequential): + """Convolution layer + Activation layer""" + def __init__( + self, in_channels, out_channels, kernel_size, bias=True, + conv=default_conv, norm=False, act=default_act): + + modules = [] + modules.append( + conv(in_channels, out_channels, kernel_size, bias=bias)) + if norm: modules.append(norm(out_channels)) + if act: modules.append(act()) + + super(BasicBlock, self).__init__(*modules) + +class ResBlock(nn.Module): + def __init__( + self, n_feats, kernel_size, bias=True, + conv=default_conv, norm=False, act=default_act): + + super(ResBlock, self).__init__() + + modules = [] + for i in range(2): + modules.append(conv(n_feats, n_feats, kernel_size, bias=bias)) + if norm: modules.append(norm(n_feats)) + if act and i == 0: modules.append(act()) + + self.body = nn.Sequential(*modules) + + def forward(self, x): + res = self.body(x) + res += x + + return res + +class ResBlock_mobile(nn.Module): + def __init__( + self, n_feats, kernel_size, bias=True, + conv=default_conv, norm=False, act=default_act, dropout=False): + + super(ResBlock_mobile, self).__init__() + + modules = [] + for i in range(2): + modules.append(conv(n_feats, n_feats, kernel_size, bias=False, groups=n_feats)) + modules.append(conv(n_feats, n_feats, 1, bias=False)) + if dropout and i == 0: modules.append(nn.Dropout2d(dropout)) + if norm: modules.append(norm(n_feats)) + if act and i == 0: modules.append(act()) + + self.body = nn.Sequential(*modules) + + def forward(self, x): + res = self.body(x) + res += x + + return res + +class Upsampler(nn.Sequential): + def __init__( + self, scale, n_feats, bias=True, + conv=default_conv, norm=False, act=False): + + modules = [] + if (scale & (scale - 1)) == 0: # Is scale = 2^n? + for _ in range(int(math.log(scale, 2))): + modules.append(conv(n_feats, 4 * n_feats, 3, bias)) + modules.append(nn.PixelShuffle(2)) + if norm: modules.append(norm(n_feats)) + if act: modules.append(act()) + elif scale == 3: + modules.append(conv(n_feats, 9 * n_feats, 3, bias)) + modules.append(nn.PixelShuffle(3)) + if norm: modules.append(norm(n_feats)) + if act: modules.append(act()) + else: + raise NotImplementedError + + super(Upsampler, self).__init__(*modules) + +# Only support 1 / 2 +class PixelSort(nn.Module): + """The inverse operation of PixelShuffle + Reduces the spatial resolution, increasing the number of channels. + Currently, scale 0.5 is supported only. + Later, torch.nn.functional.pixel_sort may be implemented. + Reference: + http://pytorch.org/docs/0.3.0/_modules/torch/nn/modules/pixelshuffle.html#PixelShuffle + http://pytorch.org/docs/0.3.0/_modules/torch/nn/functional.html#pixel_shuffle + """ + def __init__(self, upscale_factor=0.5): + super(PixelSort, self).__init__() + self.upscale_factor = upscale_factor + + def forward(self, x): + b, c, h, w = x.size() + x = x.view(b, c, 2, 2, h // 2, w // 2) + x = x.permute(0, 1, 5, 3, 2, 4).contiguous() + x = x.view(b, 4 * c, h // 2, w // 2) + + return x + +class Downsampler(nn.Sequential): + def __init__( + self, scale, n_feats, bias=True, + conv=default_conv, norm=False, act=False): + + modules = [] + if scale == 0.5: + modules.append(PixelSort()) + modules.append(conv(4 * n_feats, n_feats, 3, bias)) + if norm: modules.append(norm(n_feats)) + if act: modules.append(act()) + else: + raise NotImplementedError + + super(Downsampler, self).__init__(*modules) + diff --git a/backup/deblur/DeepDeblur-PyTorch/src/model/discriminator.py b/backup/deblur/DeepDeblur-PyTorch/src/model/discriminator.py new file mode 100644 index 0000000000000000000000000000000000000000..f988609157db3a840d9e855a0ab4d3a21419c2ad --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/model/discriminator.py @@ -0,0 +1,41 @@ +import torch.nn as nn + +class Discriminator(nn.Module): + def __init__(self, args): + super(Discriminator, self).__init__() + + # self.args = args + n_feats = args.n_feats + kernel_size = args.kernel_size + + def conv(kernel_size, in_channel, n_feats, stride, pad=None): + if pad is None: + pad = (kernel_size-1)//2 + + return nn.Conv2d(in_channel, n_feats, kernel_size, stride=stride, padding=pad, bias=False) + + self.conv_layers = nn.ModuleList([ + conv(kernel_size, 3, n_feats//2, 1), # 256 + conv(kernel_size, n_feats//2, n_feats//2, 2), # 128 + conv(kernel_size, n_feats//2, n_feats, 1), + conv(kernel_size, n_feats, n_feats, 2), # 64 + conv(kernel_size, n_feats, n_feats*2, 1), + conv(kernel_size, n_feats*2, n_feats*2, 4), # 16 + conv(kernel_size, n_feats*2, n_feats*4, 1), + conv(kernel_size, n_feats*4, n_feats*4, 4), # 4 + conv(kernel_size, n_feats*4, n_feats*8, 1), + conv(4, n_feats*8, n_feats*8, 4, 0), # 1 + ]) + + self.act = nn.LeakyReLU(negative_slope=0.2, inplace=True) + self.dense = nn.Conv2d(n_feats*8, 1, 1, bias=False) + + def forward(self, x): + + for layer in self.conv_layers: + x = self.act(layer(x)) + + x = self.dense(x) + + return x + diff --git a/backup/deblur/DeepDeblur-PyTorch/src/model/structure.py b/backup/deblur/DeepDeblur-PyTorch/src/model/structure.py new file mode 100644 index 0000000000000000000000000000000000000000..945a78603d43ca9afcccab5ba3cc1c2ceae28ff2 --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/model/structure.py @@ -0,0 +1,56 @@ +import torch.nn as nn + +from .common import ResBlock, default_conv + +def encoder(in_channels, n_feats): + """RGB / IR feature encoder + """ + + # in_channels == 1 or 3 or 4 or .... + # After 1st conv, B x n_feats x H x W + # After 2nd conv, B x 2n_feats x H/2 x W/2 + # After 3rd conv, B x 3n_feats x H/4 x W/4 + return nn.Sequential( + nn.Conv2d(in_channels, 1 * n_feats, 5, stride=1, padding=2), + nn.Conv2d(1 * n_feats, 2 * n_feats, 5, stride=2, padding=2), + nn.Conv2d(2 * n_feats, 3 * n_feats, 5, stride=2, padding=2), + ) + +def decoder(out_channels, n_feats): + """RGB / IR / Depth decoder + """ + # After 1st deconv, B x 2n_feats x H/2 x W/2 + # After 2nd deconv, B x n_feats x H x W + # After 3rd conv, B x out_channels x H x W + deconv_kargs = {'stride': 2, 'padding': 1, 'output_padding': 1} + + return nn.Sequential( + nn.ConvTranspose2d(3 * n_feats, 2 * n_feats, 3, **deconv_kargs), + nn.ConvTranspose2d(2 * n_feats, 1 * n_feats, 3, **deconv_kargs), + nn.Conv2d(n_feats, out_channels, 5, stride=1, padding=2), + ) + +# def ResNet(n_feats, in_channels=None, out_channels=None): +def ResNet(n_feats, kernel_size, n_blocks, in_channels=None, out_channels=None): + """sequential ResNet + """ + + # if in_channels is None: + # in_channels = n_feats + # if out_channels is None: + # out_channels = n_feats + # # currently not implemented + + m = [] + + if in_channels is not None: + m += [default_conv(in_channels, n_feats, kernel_size)] + + m += [ResBlock(n_feats, 3)] * n_blocks + + if out_channels is not None: + m += [default_conv(n_feats, out_channels, kernel_size)] + + + return nn.Sequential(*m) + diff --git a/backup/deblur/DeepDeblur-PyTorch/src/optim/__init__.py b/backup/deblur/DeepDeblur-PyTorch/src/optim/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3cdcaa42dec39510065564619ca0cb314da458c1 --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/optim/__init__.py @@ -0,0 +1,206 @@ +import torch +import torch.optim as optim +import torch.optim.lr_scheduler as lrs + +import os +from collections import Counter + +from model import Model +from utils import interact, Map + +class Optimizer(object): + def __init__(self, args, model): + self.args = args + + self.save_dir = os.path.join(self.args.save_dir, 'optim') + os.makedirs(self.save_dir, exist_ok=True) + + if isinstance(model, Model): + model = model.model + + # set base arguments + 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 == 'RMSPROP': + optimizer_class = optim.RMSprop + kwargs_optimizer['eps'] = args.epsilon + + # scheduler + if args.scheduler == 'step': + scheduler_class = lrs.MultiStepLR + kwargs_scheduler = { + 'milestones': args.milestones, + 'gamma': args.gamma, + } + elif args.scheduler == 'plateau': + scheduler_class = lrs.ReduceLROnPlateau + kwargs_scheduler = { + 'mode': 'min', + 'factor': args.gamma, + 'patience': 10, + 'verbose': True, + 'threshold': 0, + 'threshold_mode': 'abs', + 'cooldown': 10, + } + + self.kwargs_optimizer = kwargs_optimizer + self.scheduler_class = scheduler_class + self.kwargs_scheduler = kwargs_scheduler + + def _get_optimizer(model): + + class _Optimizer(optimizer_class): + def __init__(self, model, args, scheduler_class, kwargs_scheduler): + trainable = filter(lambda x: x.requires_grad, model.parameters()) + super(_Optimizer, self).__init__(trainable, **kwargs_optimizer) + + self.args = args + + self._register_scheduler(scheduler_class, kwargs_scheduler) + + def _register_scheduler(self, scheduler_class, kwargs_scheduler): + self.scheduler = scheduler_class(self, **kwargs_scheduler) + + def schedule(self, metrics=None): + if isinstance(self, lrs.ReduceLROnPlateau): + self.scheduler.step(metrics) + else: + self.scheduler.step() + + def get_last_epoch(self): + return self.scheduler.last_epoch + + def get_lr(self): + return self.param_groups[0]['lr'] + + def get_last_lr(self): + return self.scheduler.get_last_lr()[0] + + def state_dict(self): + state_dict = super(_Optimizer, self).state_dict() # {'state': ..., 'param_groups': ...} + state_dict['scheduler'] = self.scheduler.state_dict() + + return state_dict + + def load_state_dict(self, state_dict, epoch=None): + # optimizer + super(_Optimizer, self).load_state_dict(state_dict) # load 'state' and 'param_groups' only + # scheduler + self.scheduler.load_state_dict(state_dict['scheduler']) # should work for plateau or simple resuming + + reschedule = False + if isinstance(self.scheduler, lrs.MultiStepLR): + if self.args.milestones != list(self.scheduler.milestones) or self.args.gamma != self.scheduler.gamma: + reschedule = True + + if reschedule: + if epoch is None: + if self.scheduler.last_epoch > 1: + epoch = self.scheduler.last_epoch + else: + epoch = self.args.start_epoch - 1 + + # if False: + # # option 1. new scheduler + # for i, group in enumerate(self.param_groups): + # self.param_groups[i]['lr'] = group['initial_lr'] # reset optimizer learning rate to initial + # # self.scheduler = None + # self._register_scheduler(scheduler_class, kwargs_scheduler) + + # self.zero_grad() + # self.step() + # for _ in range(epoch): + # self.scheduler.step() + # self._step_count -= 1 + + # else: + # option 2. modify existing scheduler + self.scheduler.milestones = Counter(self.args.milestones) + self.scheduler.gamma = self.args.gamma + for i, group in enumerate(self.param_groups): + self.param_groups[i]['lr'] = group['initial_lr'] # reset optimizer learning rate to initial + multiplier = 1 + for milestone in self.scheduler.milestones: + if epoch >= milestone: + multiplier *= self.scheduler.gamma + + self.param_groups[i]['lr'] *= multiplier + + return _Optimizer(model, args, scheduler_class, kwargs_scheduler) + + self.G = _get_optimizer(model.G) + if model.D is not None: + self.D = _get_optimizer(model.D) + else: + self.D = None + + self.load(args.load_epoch) + + def zero_grad(self): + self.G.zero_grad() + + def step(self): + self.G.step() + + def schedule(self, metrics=None): + self.G.schedule(metrics) + if self.D is not None: + self.D.schedule(metrics) + + def get_last_epoch(self): + return self.G.get_last_epoch() + + def get_lr(self): + return self.G.get_lr() + + def get_last_lr(self): + return self.G.get_last_lr() + + def state_dict(self): + state_dict = Map() + state_dict.G = self.G.state_dict() + if self.D is not None: + state_dict.D = self.D.state_dict() + + return state_dict.toDict() + + def load_state_dict(self, state_dict, epoch=None): + state_dict = Map(**state_dict) + self.G.load_state_dict(state_dict.G, epoch) + if self.D is not None: + self.D.load_state_dict(state_dict.D, epoch) + + def _save_path(self, epoch=None): + epoch = epoch if epoch is not None else self.get_last_epoch() + save_path = os.path.join(self.save_dir, 'optim-{:d}.pt'.format(epoch)) + + return save_path + + def save(self, epoch=None): + if epoch is None: + epoch = self.G.scheduler.last_epoch + torch.save(self.state_dict(), self._save_path(epoch)) + + def load(self, epoch): + if epoch > 0: + print('Loading optimizer from {}'.format(self._save_path(epoch))) + self.load_state_dict(torch.load(self._save_path(epoch), map_location=self.args.device), epoch=epoch) + + elif epoch == 0: + pass + else: + raise NotImplementedError + + return + diff --git a/backup/deblur/DeepDeblur-PyTorch/src/optim/__pycache__/__init__.cpython-37.pyc b/backup/deblur/DeepDeblur-PyTorch/src/optim/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..22f0672ee6739cd359e72e7fdcd665f9803d74d4 Binary files /dev/null and b/backup/deblur/DeepDeblur-PyTorch/src/optim/__pycache__/__init__.cpython-37.pyc differ diff --git a/backup/deblur/DeepDeblur-PyTorch/src/optim/warm_multi_step_lr.py b/backup/deblur/DeepDeblur-PyTorch/src/optim/warm_multi_step_lr.py new file mode 100644 index 0000000000000000000000000000000000000000..bb034f955104fb4b6c74bb3d5e5056e9626ab0b5 --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/optim/warm_multi_step_lr.py @@ -0,0 +1,32 @@ +import math +from bisect import bisect_right +from torch.optim.lr_scheduler import _LRScheduler + +# MultiStep learning rate scheduler with warm restart +class WarmMultiStepLR(_LRScheduler): + def __init__(self, optimizer, milestones, gamma=0.1, last_epoch=-1, scale=1): + if not list(milestones) == sorted(milestones): + raise ValueError( + 'Milestones should be a list of increasing integers. Got {}', + milestones + ) + + self.milestones = milestones + self.gamma = gamma + self.scale = scale + + self.warmup_epochs = 5 + self.gradual = (self.scale - 1) / self.warmup_epochs + super(WarmMultiStepLR, self).__init__(optimizer, last_epoch) + + def get_lr(self): + if self.last_epoch < self.warmup_epochs: + return [ + base_lr * (1 + self.last_epoch * self.gradual) / self.scale + for base_lr in self.base_lrs + ] + else: + return [ + base_lr * self.gamma ** bisect_right(self.milestones, self.last_epoch) + for base_lr in self.base_lrs + ] diff --git a/backup/deblur/DeepDeblur-PyTorch/src/option.py b/backup/deblur/DeepDeblur-PyTorch/src/option.py new file mode 100644 index 0000000000000000000000000000000000000000..fa8ba1ba2ba540b8c4c97bdc8a370c110d5d9af3 --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/option.py @@ -0,0 +1,274 @@ +"""optionional argument parsing""" +# pylint: disable=C0103, C0301 +import argparse +import datetime +import os +import re +import shutil +import time + +import torch +import torch.distributed as dist +import torch.backends.cudnn as cudnn + +from utils import interact +from utils import str2bool, int2str + +import template + +# Training settings +parser = argparse.ArgumentParser(description='Dynamic Scene Deblurring') + +# Device specifications +group_device = parser.add_argument_group('Device specs') +group_device.add_argument('--seed', type=int, default=-1, help='random seed') +group_device.add_argument('--num_workers', type=int, default=7, help='the number of dataloader workers') +group_device.add_argument('--device_type', type=str, choices=('cpu', 'cuda'), default='cuda', help='device to run models') +group_device.add_argument('--device_index', type=int, default=0, help='device id to run models') +group_device.add_argument('--n_GPUs', type=int, default=1, help='the number of GPUs for training') +group_device.add_argument('--distributed', type=str2bool, default=False, help='use DistributedDataParallel instead of DataParallel for better speed') +group_device.add_argument('--launched', type=str2bool, default=False, help='identify if main.py was executed from launch.py. Do not set this to be true using main.py.') + +group_device.add_argument('--master_addr', type=str, default='127.0.0.1', help='master address for distributed') +group_device.add_argument('--master_port', type=int2str, default='8023', help='master port for distributed') +group_device.add_argument('--dist_backend', type=str, default='nccl', help='distributed backend') +group_device.add_argument('--init_method', type=str, default='env://', help='distributed init method URL to discover peers') +group_device.add_argument('--rank', type=int, default=0, help='rank of the distributed process (gpu id). 0 is the master process.') +group_device.add_argument('--world_size', type=int, default=1, help='world_size for distributed training (number of GPUs)') + +# Data +group_data = parser.add_argument_group('Data specs') +group_data.add_argument('--data_root', type=str, default='/data/ssd/public/czli/deblur', help='dataset root location') +group_data.add_argument('--dataset', type=str, default=None, help='training/validation/test dataset name, has priority if not None') +group_data.add_argument('--data_train', type=str, default='GOPRO_Large', help='training dataset name') +group_data.add_argument('--data_val', type=str, default=None, help='validation dataset name') +group_data.add_argument('--data_test', type=str, default='GOPRO_Large', help='test dataset name') +group_data.add_argument('--blur_key', type=str, default='blur_gamma', choices=('blur', 'blur_gamma'), help='blur type from camera response function for GOPRO_Large dataset') +group_data.add_argument('--rgb_range', type=int, default=255, help='RGB pixel value ranging from 0') + +# Model +group_model = parser.add_argument_group('Model specs') +group_model.add_argument('--model', type=str, default='MSResNet', help='model architecture') +group_model.add_argument('--pretrained', type=str, default='', help='pretrained model location') +group_model.add_argument('--n_scales', type=int, default=3, help='multi-scale deblurring level') +group_model.add_argument('--gaussian_pyramid', type=str2bool, default=True, help='gaussian pyramid input/target') +group_model.add_argument('--n_resblocks', type=int, default=19, help='number of residual blocks per scale') +group_model.add_argument('--n_feats', type=int, default=64, help='number of feature maps') +group_model.add_argument('--kernel_size', type=int, default=5, help='size of conv kernel') +group_model.add_argument('--downsample', type=str, choices=('Gaussian', 'bicubic', 'stride'), default='Gaussian', help='input pyramid generation method') + +group_model.add_argument('--precision', type=str, default='single', choices=('single', 'half'), help='FP precision for test(single | half)') + +# amp +group_amp = parser.add_argument_group('AMP specs') +group_amp.add_argument('--amp', type=str2bool, default=False, help='use automatic mixed precision training') +group_amp.add_argument('--init_scale', type=float, default=1024., help='initial loss scale') + +# Training +group_train = parser.add_argument_group('Training specs') +group_train.add_argument('--patch_size', type=int, default=256, help='training patch size') +group_train.add_argument('--batch_size', type=int, default=16, help='input batch size for training') +group_train.add_argument('--split_batch', type=int, default=1, help='split a minibatch into smaller chunks') +group_train.add_argument('--augment', type=str2bool, default=True, help='train with data augmentation') + +# Testing +group_test = parser.add_argument_group('Testing specs') +group_test.add_argument('--validate_every', type=int, default=10, help='do validation at every N epochs') +group_test.add_argument('--test_every', type=int, default=10, help='do test at every N epochs') +# group_test.add_argument('--chop', type=str2bool, default=False, help='memory-efficient forward') +# group_test.add_argument('--self_ensemble', type=str2bool, default=False, help='self-ensembled testing') + +# Action +group_action = parser.add_argument_group('Source behavior') +group_action.add_argument('--do_train', type=str2bool, default=True, help='do train the model') +group_action.add_argument('--do_validate', type=str2bool, default=True, help='do validate the model') +group_action.add_argument('--do_test', type=str2bool, default=True, help='do test the model') +group_action.add_argument('--demo', type=str2bool, default=False, help='demo') +group_action.add_argument('--demo_input_dir', type=str, default='', help='demo input directory') +group_action.add_argument('--demo_output_dir', type=str, default='', help='demo output directory') + +# Optimization +group_optim = parser.add_argument_group('Optimization specs') +group_optim.add_argument('--lr', type=float, default=1e-4, help='learning rate') +group_optim.add_argument('--milestones', type=int, nargs='+', default=[500, 750, 900], help='learning rate decay per N epochs') +group_optim.add_argument('--scheduler', default='step', choices=('step', 'plateau'), help='learning rate scheduler type') +group_optim.add_argument('--gamma', type=float, default=0.5, help='learning rate decay factor for step decay') +group_optim.add_argument('--optimizer', default='ADAM', choices=('SGD', 'ADAM', 'RMSprop'), help='optimizer to use (SGD | ADAM | RMSProp)') +group_optim.add_argument('--momentum', type=float, default=0.9, help='SGD momentum') +group_optim.add_argument('--betas', type=float, nargs=2, default=(0.9, 0.999), help='ADAM betas') +group_optim.add_argument('--epsilon', type=float, default=1e-8, help='ADAM epsilon') +group_optim.add_argument('--weight_decay', type=float, default=0, help='weight decay') + +# Loss +group_loss = parser.add_argument_group('Loss specs') +group_loss.add_argument('--loss', type=str, default='1*L1', help='loss function configuration') +group_loss.add_argument('--metric', type=str, default='PSNR,SSIM', help='metric function configuration. ex) None | PSNR | SSIM | PSNR,SSIM') + +# Logging +group_log = parser.add_argument_group('Logging specs') +group_log.add_argument('--save_dir', type=str, default='', help='subdirectory to save experiment logs') +# group_log.add_argument('--load_dir', type=str, default='', help='subdirectory to load experiment logs') +group_log.add_argument('--start_epoch', type=int, default=-1, help='(re)starting epoch number') +group_log.add_argument('--end_epoch', type=int, default=1000, help='ending epoch number') +group_log.add_argument('--load_epoch', type=int, default=-1, help='epoch number to load model (start_epoch-1 for training, start_epoch for testing)') +group_log.add_argument('--save_every', type=int, default=10, help='save model/optimizer at every N epochs') +group_log.add_argument('--save_results', type=str, default='part', choices=('none', 'part', 'all'), help='save none/part/all of result images') + +# Debugging +group_debug = parser.add_argument_group('Debug specs') +group_debug.add_argument('--stay', type=str2bool, default=False, help='stay at interactive console after trainer initialization') + +parser.add_argument('--template', type=str, default='', help='argument template option') + +args = parser.parse_args() +template.set_template(args) + +args.data_root = os.path.expanduser(args.data_root) # recognize home directory +now = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S') +if args.save_dir == '': + args.save_dir = now +args.save_dir = os.path.join('../experiment', args.save_dir) +os.makedirs(args.save_dir, exist_ok=True) + +if args.start_epoch < 0: # start from scratch or continue from the last epoch + # check if there are any models saved before + model_dir = os.path.join(args.save_dir, 'models') + model_prefix = 'model-' + if os.path.exists(model_dir): + model_list = [name for name in os.listdir(model_dir) if name.startswith(model_prefix)] + last_epoch = 0 + for name in model_list: + epochNumber = int(re.findall('\\d+', name)[0]) # model example name model-100.pt + if last_epoch < epochNumber: + last_epoch = epochNumber + + args.start_epoch = last_epoch + 1 + else: + # train from scratch + args.start_epoch = 1 +elif args.start_epoch == 0: + # remove existing directory and start over + if args.rank == 0: # maybe local rank + shutil.rmtree(args.save_dir, ignore_errors=True) + os.makedirs(args.save_dir, exist_ok=True) + args.start_epoch = 1 + +if args.load_epoch < 0: # load_epoch == start_epoch when doing a post-training test for a specific epoch + args.load_epoch = args.start_epoch - 1 + +if args.pretrained: + if args.start_epoch <= 1: + args.pretrained = os.path.join('../experiment', args.pretrained) + else: + print('starting from epoch {}! ignoring pretrained model path..'.format(args.start_epoch)) + args.pretrained = '' + +if args.model == 'MSResNet': + args.gaussian_pyramid = True + +argname = os.path.join(args.save_dir, 'args.pt') +argname_txt = os.path.join(args.save_dir, 'args.txt') +if args.start_epoch > 1: + # load previous arguments and keep the necessary ones same + + if os.path.exists(argname): + args_old = torch.load(argname) + + load_list = [] # list of arguments that are fixed + # training + load_list += ['patch_size'] + load_list += ['batch_size'] + # data format + load_list += ['rgb_range'] + load_list += ['blur_key'] + # model architecture + load_list += ['n_scales'] + load_list += ['n_resblocks'] + load_list += ['n_feats'] + + for arg_part in load_list: + vars(args)[arg_part] = vars(args_old)[arg_part] + +if args.dataset is not None: + args.data_train = args.dataset + args.data_val = args.dataset if args.dataset != 'GOPRO_Large' else None + args.data_test = args.dataset + +if args.data_val is None: + args.do_validate = False + +if args.demo_input_dir: + args.demo = True + +if args.demo: + assert os.path.basename(args.save_dir) != now, 'You should specify pretrained directory by setting --save_dir SAVE_DIR' + + args.data_train = '' + args.data_val = '' + args.data_test = '' + + args.do_train = False + args.do_validate = False + args.do_test = False + + assert len(args.demo_input_dir) > 0, 'Please specify demo_input_dir!' + args.demo_input_dir = os.path.expanduser(args.demo_input_dir) + if args.demo_output_dir: + args.demo_output_dir = os.path.expanduser(args.demo_output_dir) + + args.save_results = 'all' + +if args.amp: + args.precision = 'single' # model parameters should stay in fp32 + +if args.seed < 0: + args.seed = int(time.time()) + +# save arguments +if args.rank == 0: + torch.save(args, argname) + with open(argname_txt, 'a') as file: + file.write('execution at {}\n'.format(now)) + + for key in args.__dict__: + file.write(key + ': ' + str(args.__dict__[key]) + '\n') + + file.write('\n') + +# device and type +if args.device_type == 'cuda' and not torch.cuda.is_available(): + raise Exception("GPU not available!") + +if not args.distributed: + args.rank = 0 + +def setup(args): + cudnn.benchmark = True + + if args.distributed: + os.environ['MASTER_ADDR'] = args.master_addr + os.environ['MASTER_PORT'] = args.master_port + + args.device_index = args.rank + args.world_size = args.n_GPUs # consider single-node training + + # initialize the process group + dist.init_process_group(args.dist_backend, init_method=args.init_method, rank=args.rank, world_size=args.world_size) + + args.device = torch.device(args.device_type, args.device_index) + args.dtype = torch.float32 + args.dtype_eval = torch.float32 if args.precision == 'single' else torch.float16 + + # set seed for processes (distributed: different seed for each process) + # model parameters are synchronized explicitly at initial + torch.manual_seed(args.seed) + if args.device_type == 'cuda': + torch.cuda.set_device(args.device) + if args.rank == 0: + torch.cuda.manual_seed_all(args.seed) + + return args + +def cleanup(args): + if args.distributed: + dist.destroy_process_group() diff --git a/backup/deblur/DeepDeblur-PyTorch/src/prepare.sh b/backup/deblur/DeepDeblur-PyTorch/src/prepare.sh new file mode 100644 index 0000000000000000000000000000000000000000..60720612f75a0468d0de4bd6b175f5146fe309a1 --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/prepare.sh @@ -0,0 +1,16 @@ +#!/bin/bash +workplace=`pwd -P` + +if [ ! -d "/data/ssd/public/czli/deblur/GOPRO_Large" ]; then + workplace=`pwd` + echo "Copying dataset to ssd" + cd /research/dept7/czli/deblur/dataset + mkdir -p /data/ssd/public/czli/deblur/GOPRO_Large + cp GOPRO_Large.zip /data/ssd/public/czli/deblur/GOPRO_Large + cd /data/ssd/public/czli/deblur/GOPRO_Large + echo "Dumping zip in data path:" `pwd` + for f in *.zip; do unzip "$f"; done +fi + +cd "$workplace" +echo "Workplace:" `pwd` diff --git a/backup/deblur/DeepDeblur-PyTorch/src/template.py b/backup/deblur/DeepDeblur-PyTorch/src/template.py new file mode 100644 index 0000000000000000000000000000000000000000..c18d5e0b9d46185bda55038e4a284eb659f6cc6a --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/template.py @@ -0,0 +1,9 @@ +def set_template(args): + if args.template.find('gopro') >= 0: + args.dataset = 'GOPRO_Large' + args.milestones = [500, 750, 900] + args.end_epoch = 1000 + elif args.template.find('reds') >= 0: + args.dataset = 'REDS' + args.milestones = [100, 150, 180] + args.end_epoch = 200 diff --git a/backup/deblur/DeepDeblur-PyTorch/src/train.py b/backup/deblur/DeepDeblur-PyTorch/src/train.py new file mode 100644 index 0000000000000000000000000000000000000000..43448bcb4fe7b36c4ce85e978b3548435680274a --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/train.py @@ -0,0 +1,225 @@ +import os +from tqdm import tqdm + +import torch + +import data.common +from utils import interact, MultiSaver + +import torch.cuda.amp as amp + +class Trainer(): + + def __init__(self, args, model, criterion, optimizer, loaders): + print('===> Initializing trainer') + self.args = args + self.mode = 'train' # 'val', 'test' + self.epoch = args.start_epoch + self.save_dir = args.save_dir + + self.model = model + self.criterion = criterion + self.optimizer = optimizer + self.loaders = loaders + + self.do_train = args.do_train + self.do_validate = args.do_validate + self.do_test = args.do_test + + self.device = args.device + self.dtype = args.dtype + self.dtype_eval = torch.float32 if args.precision == 'single' else torch.float16 + + if self.args.demo and self.args.demo_output_dir: + self.result_dir = self.args.demo_output_dir + else: + self.result_dir = os.path.join(self.save_dir, 'result') + os.makedirs(self.result_dir, exist_ok=True) + print('results are saved in {}'.format(self.result_dir)) + + self.imsaver = MultiSaver(self.result_dir) + + self.is_slave = self.args.launched and self.args.rank != 0 + + self.scaler = amp.GradScaler( + init_scale=self.args.init_scale, + enabled=self.args.amp + ) + + def save(self, epoch=None): + epoch = self.epoch if epoch is None else epoch + if epoch % self.args.save_every == 0: + if self.mode == 'train': + self.model.save(epoch) + self.optimizer.save(epoch) + self.criterion.save() + + return + + def load(self, epoch=None, pretrained=None): + if epoch is None: + epoch = self.args.load_epoch + self.epoch = epoch + self.model.load(epoch, pretrained) + self.optimizer.load(epoch) + self.criterion.load(epoch) + + return + + def train(self, epoch): + self.mode = 'train' + self.epoch = epoch + + self.model.train() + self.model.to(dtype=self.dtype) + + self.criterion.train() + self.criterion.epoch = epoch + + if not self.is_slave: + print('[Epoch {} / lr {:.2e}]'.format( + epoch, self.optimizer.get_lr() + )) + + if self.args.distributed: + self.loaders[self.mode].sampler.set_epoch(epoch) + if self.is_slave: + tq = self.loaders[self.mode] + else: + tq = tqdm(self.loaders[self.mode], ncols=80, smoothing=0, bar_format='{desc}|{bar}{r_bar}') + + torch.set_grad_enabled(True) + for idx, batch in enumerate(tq): + self.optimizer.zero_grad() + + input, target = data.common.to( + batch[0], batch[1], device=self.device, dtype=self.dtype) + + with amp.autocast(self.args.amp): + output = self.model(input) + loss = self.criterion(output, target) + + self.scaler.scale(loss).backward() + self.scaler.step(self.optimizer.G) + self.scaler.update() + + if isinstance(tq, tqdm): + tq.set_description(self.criterion.get_loss_desc()) + + self.criterion.normalize() + if isinstance(tq, tqdm): + tq.set_description(self.criterion.get_loss_desc()) + tq.display(pos=-1) # overwrite with synchronized loss + + self.criterion.step() + self.optimizer.schedule(self.criterion.get_last_loss()) + + if self.args.rank == 0: + self.save(epoch) + + return + + def evaluate(self, epoch, mode='val'): + self.mode = mode + self.epoch = epoch + + self.model.eval() + self.model.to(dtype=self.dtype_eval) + + if mode == 'val': + self.criterion.validate() + elif mode == 'test': + self.criterion.test() + self.criterion.epoch = epoch + + self.imsaver.join_background() + + if self.is_slave: + tq = self.loaders[self.mode] + else: + tq = tqdm(self.loaders[self.mode], ncols=80, smoothing=0, bar_format='{desc}|{bar}{r_bar}') + + compute_loss = True + torch.set_grad_enabled(False) + for idx, batch in enumerate(tq): + input, target = data.common.to( + batch[0], batch[1], device=self.device, dtype=self.dtype_eval) + with amp.autocast(self.args.amp): + output = self.model(input) + + if mode == 'demo': # remove padded part + pad_width = batch[2] + output[0], _ = data.common.pad(output[0], pad_width=pad_width, negative=True) + + if isinstance(batch[1], torch.BoolTensor): + compute_loss = False + + if compute_loss: + self.criterion(output, target) + if isinstance(tq, tqdm): + tq.set_description(self.criterion.get_loss_desc()) + + if self.args.save_results != 'none': + if isinstance(output, (list, tuple)): + result = output[0] # select last output in a pyramid + elif isinstance(output, torch.Tensor): + result = output + + names = batch[-1] + + if self.args.save_results == 'part' and compute_loss: # save all when GT not available + indices = batch[-2] + save_ids = [save_id for save_id, idx in enumerate(indices) if idx % 10 == 0] + + result = result[save_ids] + names = [names[save_id] for save_id in save_ids] + + self.imsaver.save_image(result, names) + + if compute_loss: + self.criterion.normalize() + if isinstance(tq, tqdm): + tq.set_description(self.criterion.get_loss_desc()) + tq.display(pos=-1) # overwrite with synchronized loss + + self.criterion.step() + if self.args.rank == 0: + self.save() + + self.imsaver.end_background() + + def validate(self, epoch): + self.evaluate(epoch, 'val') + return + + def test(self, epoch): + self.evaluate(epoch, 'test') + return + + def fill_evaluation(self, epoch, mode=None, force=False): + if epoch <= 0: + return + + if mode is not None: + self.mode = mode + + do_eval = force + if not force: + loss_missing = epoch not in self.criterion.loss_stat[self.mode]['Total'] # should it switch to all loss types? + + metric_missing = False + for metric_type in self.criterion.metric: + if epoch not in self.criterion.metric_stat[mode][metric_type]: + metric_missing = True + + do_eval = loss_missing or metric_missing + + if do_eval: + try: + self.load(epoch) + self.evaluate(epoch, self.mode) + except: + # print('saved model/optimizer at epoch {} not found!'.format(epoch)) + pass + + return diff --git a/backup/deblur/DeepDeblur-PyTorch/src/utils.py b/backup/deblur/DeepDeblur-PyTorch/src/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..d129915d50c0c799765adafdf607ca5c3c16b266 --- /dev/null +++ b/backup/deblur/DeepDeblur-PyTorch/src/utils.py @@ -0,0 +1,200 @@ +import readline +import rlcompleter +readline.parse_and_bind("tab: complete") +import code +import pdb + +import time +import argparse +import os +import imageio +import torch +import torch.multiprocessing as mp + +# debugging tools +def interact(local=None): + """interactive console with autocomplete function. Useful for debugging. + interact(locals()) + """ + if local is None: + local=dict(globals(), **locals()) + + readline.set_completer(rlcompleter.Completer(local).complete) + code.interact(local=local) + +def set_trace(local=None): + """debugging with pdb + """ + if local is None: + local=dict(globals(), **locals()) + + pdb.Pdb.complete = rlcompleter.Completer(local).complete + pdb.set_trace() + +# timer +class Timer(): + """Brought from https://github.com/thstkdgus35/EDSR-PyTorch + """ + def __init__(self): + self.acc = 0 + self.tic() + + def tic(self): + self.t0 = time.time() + + def toc(self): + return time.time() - self.t0 + + def hold(self): + self.acc += self.toc() + + def release(self): + ret = self.acc + self.acc = 0 + + return ret + + def reset(self): + self.acc = 0 + + +# argument parser type casting functions +def str2bool(val): + """enable default constant true arguments""" + # https://stackoverflow.com/questions/15008758/parsing-boolean-values-with-argparse + if isinstance(val, bool): + return val + elif val.lower() == 'true': + return True + elif val.lower() == 'false': + return False + else: + raise argparse.ArgumentTypeError('Boolean value expected') + +def int2str(val): + """convert int to str for environment variable related arguments""" + if isinstance(val, int): + return str(val) + elif isinstance(val, str): + return val + else: + raise argparse.ArgumentTypeError('number value expected') + + +# image saver using multiprocessing queue +class MultiSaver(): + def __init__(self, result_dir=None): + self.queue = None + self.process = None + self.result_dir = result_dir + + def begin_background(self): + self.queue = mp.Queue() + + def t(queue): + while True: + if queue.empty(): + continue + img, name = queue.get() + if name: + try: + basename, ext = os.path.splitext(name) + if ext != '.png': + name = '{}.png'.format(basename) + imageio.imwrite(name, img) + except Exception as e: + print(e) + else: + return + + worker = lambda: mp.Process(target=t, args=(self.queue,), daemon=False) + cpu_count = min(8, mp.cpu_count() - 1) + self.process = [worker() for _ in range(cpu_count)] + for p in self.process: + p.start() + + def end_background(self): + if self.queue is None: + return + + for _ in self.process: + self.queue.put((None, None)) + + def join_background(self): + if self.queue is None: + return + + while not self.queue.empty(): + time.sleep(0.5) + + for p in self.process: + p.join() + + self.queue = None + + def save_image(self, output, save_names, result_dir=None): + result_dir = result_dir if self.result_dir is None else self.result_dir + if result_dir is None: + raise Exception('no result dir specified!') + + if self.queue is None: + try: + self.begin_background() + except Exception as e: + print(e) + return + + # assume NCHW format + if output.ndim == 2: + output = output.expand([1, 1] + list(output.shape)) + elif output.ndim == 3: + output = output.expand([1] + list(output.shape)) + + for output_img, save_name in zip(output, save_names): + # assume image range [0, 255] + output_img = output_img.add_(0.5).clamp_(0, 255).permute(1, 2, 0).to('cpu', torch.uint8).numpy() + + save_name = os.path.join(result_dir, save_name) + save_dir = os.path.dirname(save_name) + os.makedirs(save_dir, exist_ok=True) + + self.queue.put((output_img, save_name)) + + return + +class Map(dict): + """ + https://stackoverflow.com/questions/2352181/how-to-use-a-dot-to-access-members-of-dictionary + Example: + m = Map({'first_name': 'Eduardo'}, last_name='Pool', age=24, sports=['Soccer']) + """ + def __init__(self, *args, **kwargs): + super(Map, self).__init__(*args, **kwargs) + for arg in args: + if isinstance(arg, dict): + for k, v in arg.items(): + self[k] = v + + if kwargs: + for k, v in kwargs.items(): + self[k] = v + + def __getattr__(self, attr): + return self.get(attr) + + def __setattr__(self, key, value): + self.__setitem__(key, value) + + def __setitem__(self, key, value): + super(Map, self).__setitem__(key, value) + self.__dict__.update({key: value}) + + def __delattr__(self, item): + self.__delitem__(item) + + def __delitem__(self, key): + super(Map, self).__delitem__(key) + del self.__dict__[key] + + def toDict(self): + return self.__dict__ \ No newline at end of file diff --git a/backup/deblur/LICENSE b/backup/deblur/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..28e0d6a101d6262cc30ae90f12317455dc787c17 --- /dev/null +++ b/backup/deblur/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 Seungjun Nah + +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/backup/deblur/README.md b/backup/deblur/README.md new file mode 100644 index 0000000000000000000000000000000000000000..615391671467edef39f88838666f27b4b63d535b --- /dev/null +++ b/backup/deblur/README.md @@ -0,0 +1,216 @@ +# DeepDeblur-PyTorch + +This is a pytorch implementation of our research. Please refer to our CVPR 2017 paper for details: + +Deep Multi-scale Convolutional Neural Network for Dynamic Scene Deblurring +[[paper](http://openaccess.thecvf.com/content_cvpr_2017/papers/Nah_Deep_Multi-Scale_Convolutional_CVPR_2017_paper.pdf)] +[[supplementary](http://openaccess.thecvf.com/content_cvpr_2017/supplemental/Nah_Deep_Multi-Scale_Convolutional_2017_CVPR_supplemental.zip)] +[[slide](https://drive.google.com/file/d/1sj7l2tGgJR-8wTyauvnSDGpiokjOzX_C/view?usp=sharing)] + +If you find our work useful in your research or publication, please cite our work: +``` +@InProceedings{Nah_2017_CVPR, + author = {Nah, Seungjun and Kim, Tae Hyun and Lee, Kyoung Mu}, + title = {Deep Multi-Scale Convolutional Neural Network for Dynamic Scene Deblurring}, + booktitle = {The IEEE Conference on Computer Vision and Pattern Recognition (CVPR)}, + month = {July}, + year = {2017} +} +``` + +Original Torch7 implementaion is available [here](https://github.com/SeungjunNah/DeepDeblur_release). + +## Dependencies + +* python 3 (tested with anaconda3) +* PyTorch 1.6 +* tqdm +* imageio +* scikit-image +* numpy +* matplotlib +* readline + +Please refer to [this issue](https://github.com/SeungjunNah/DeepDeblur-PyTorch/issues/5#issuecomment-651177352) for the versions. + +## Datasets + +* GOPRO_Large: [link](https://seungjunnah.github.io/Datasets/gopro) +* REDS: [link](https://seungjunnah.github.io/Datasets/reds) + +## Usage examples + +* Preparing dataset + +Before running the code, put the datasets on a desired directory. By default, the data root is set as '~/Research/dataset' +See: [src/option.py](src/option.py) +```python +group_data.add_argument('--data_root', type=str, default='~/Research/dataset', help='dataset root location') +``` +Put your dataset under ```args.data_root```. + +The dataset location should be like: +```bash +# GOPRO_Large dataset +~/Research/dataset/GOPRO_Large/train/GOPR0372_07_00/blur_gamma/.... +# REDS dataset +~/Research/dataset/REDS/train/train_blur/000/... +``` + +* Example commands + +```bash +# single GPU training +python main.py --n_GPUs 1 --batch_size 8 # save the results in default experiment/YYYY-MM-DD_hh-mm-ss +python main.py --n_GPUs 1 --batch_size 8 --save_dir GOPRO_L1 # save the results in experiment/GOPRO_L1 + +# adversarial training +python main.py --n_GPUs 1 --batch_size 8 --loss 1*L1+1*ADV +python main.py --n_GPUs 1 --batch_size 8 --loss 1*L1+3*ADV +python main.py --n_GPUs 1 --batch_size 8 --loss 1*L1+0.1*ADV + +# train with GOPRO_Large dataset +python main.py --n_GPUs 1 --batch_size 8 --dataset GOPRO_Large +# train with REDS dataset (always set --do_test false) +python main.py --n_GPUs 1 --batch_size 8 --dataset REDS --do_test false --milestones 100 150 180 --end_epoch 200 + +# save part of the evaluation results (default) +python main.py --n_GPUs 1 --batch_size 8 --dataset GOPRO_Large --save_results part +# save no evaluation results (faster at test time) +python main.py --n_GPUs 1 --batch_size 8 --dataset GOPRO_Large --save_results none +# save all of the evaluation results +python main.py --n_GPUs 1 --batch_size 8 --dataset GOPRO_Large --save_results all +``` + +```bash +# multi-GPU training (DataParallel) +python main.py --n_GPUs 2 --batch_size 16 +``` + +```bash +# multi-GPU training (DistributedDataParallel), recommended for the best speed +# single command version (do not set ranks) +python launch.py --n_GPUs 2 main.py --batch_size 16 + +# multi-command version (type in independent shells with the corresponding ranks, useful for debugging) +python main.py --batch_size 16 --distributed true --n_GPUs 2 --rank 0 # shell 0 +python main.py --batch_size 16 --distributed true --n_GPUs 2 --rank 1 # shell 1 +``` + +```bash +# single precision inference (default) +python launch.py --n_GPUs 2 main.py --batch_size 16 --precision single + +# half precision inference (faster and requires less memory) +python launch.py --n_GPUs 2 main.py --batch_size 16 --precision half + +# half precision inference with AMP +python launch.py --n_GPUs 2 main.py --batch_size 16 --amp true +``` + +```bash +# optional mixed-precision training +# mixed precision training may result in different accuracy +python main.py --n_GPUs 1 --batch_size 16 --amp true +python main.py --n_GPUs 2 --batch_size 16 --amp true +python launch.py --n_GPUs 2 main.py --batch_size 16 --amp true +``` + +```bash +# Advanced usage examples +# using launch.py is recommended for the best speed and convenience +python launch.py --n_GPUs 4 main.py --dataset GOPRO_Large +python launch.py --n_GPUs 4 main.py --dataset GOPRO_Large --milestones 500 750 900 --end_epoch 1000 --save_results none +python launch.py --n_GPUs 4 main.py --dataset GOPRO_Large --milestones 500 750 900 --end_epoch 1000 --save_results part +python launch.py --n_GPUs 4 main.py --dataset GOPRO_Large --milestones 500 750 900 --end_epoch 1000 --save_results all +python launch.py --n_GPUs 4 main.py --dataset GOPRO_Large --milestones 500 750 900 --end_epoch 1000 --save_results all --amp true + +python launch.py --n_GPUs 4 main.py --dataset REDS --milestones 100 150 180 --end_epoch 200 --save_results all --do_test false +python launch.py --n_GPUs 4 main.py --dataset REDS --milestones 100 150 180 --end_epoch 200 --save_results all --do_test false --do_validate false +``` + +```bash +# Commands used to generate the below results +python launch.py --n_GPUs 2 main.py --dataset GOPRO_Large --milestones 500 750 900 --end_epoch 1000 +python launch.py --n_GPUs 4 main.py --dataset REDS --milestones 100 150 180 --end_epoch 200 --do_test false +``` + +For more advanced usage, please take a look at src/option.py + +## Results + +* Single-precision training results + +Dataset | GOPRO_Large | REDS +:--:|:--:|:--: +PSNR | 30.40 | 32.89 +SSIM | 0.9018 | 0.9207 +Download | [link](https://drive.google.com/file/d/1-wGC6s2D2ba-PSV60AeHf48HtYd9JkQ4/view?usp=sharing) | [link](https://drive.google.com/file/d/1aSPgVsNcPNqeGPn0Y2uGmgIwaIn5Njkv/view?usp=sharing) + +* Mixed-precision training results + +Dataset | GOPRO_Large | REDS | REDS (GOPRO_Large pretrained) +:--:|:--:|:--:|:--: +PSNR| 30.42 | 32.95 | 33.13 +SSIM| 0.9021 | 0.9209 | 0.9237 +Download | [link](https://drive.google.com/file/d/1TgiiiB-4lwWIIy8c-oSSkIy5g4GvDBKB/view?usp=sharing) | [link](https://drive.google.com/file/d/10hH5vtfGUUpy8jLvIBRCBqRoEhWRO1va/view?usp=sharing) | [link](https://drive.google.com/file/d/1YV6uhGLDBbvaiWN2_cYgUhYakmvLMAM9/view?usp=sharing) + +Mixed-precision training uses less memory and is faster, especially on NVIDIA Turing-generation GPUs. +Loss scaling technique is adopted to cope with the narrow representation range of fp16. +This could improve/degrade accuracy. + +* Inference speed on RTX 2080 Ti (resolution: 1280x720) + +Inference in half precision has negligible effect on accuracy while it requires less memory and computation time. +type | FP32 | FP16 +:--:|:--:|:--: +fps | 1.06 | 3.03 +time (s) | 0.943 | 0.330 + +## Demo + +To use the trained models, download files, unzip, and put them under DeepDeblur-PyTorch/experiment +* [GOPRO_L1](https://drive.google.com/file/d/1AfZhyUXEA8_UdZco9EdtpWjTBAb8BbWv/view?usp=sharing) +* [REDS_L1](https://drive.google.com/file/d/1UwFNXnGBz2rCBxhvq2gKt9Uhj5FeEsa4/view?usp=sharing) +* [GOPRO_L1_amp](https://drive.google.com/file/d/1ZcP3l2ZXj-C6yrDge5d3UxcaAKRN725w/view?usp=sharing) +* [REDS_L1_amp](https://drive.google.com/file/d/1do_HOjVFj2AYTX4BbwQ0enELRWtzhW6F/view?usp=sharing) +* [REDS_L1_amp_pretrained](https://drive.google.com/file/d/1BkEgUrFtOSymVnaADfptOvqfNOYiD3J1/view?usp=sharing) + +```bash +python main.py --save_dir SAVE_DIR --demo true --demo_input_dir INPUT_DIR_NAME --demo_output_dir OUTPUT_DIR_NAME +# SAVE_DIR is the experiment directory where the parameters are saved (GOPRO_L1, REDS_L1) +# SAVE_DIR is relative to DeepDeblur-PyTorch/experiment +# demo_output_dir is by default SAVE_DIR/results +# image dataloader looks into DEMO_INPUT_DIR, recursively + +# example +# single GPU (GOPRO_Large, single precision) +python main.py --save_dir GOPRO_L1 --demo true --demo_input_dir ~/Research/dataset/GOPRO_Large/test/GOPR0384_11_00/blur_gamma +# single GPU (GOPRO_Large, amp-trained model, half precision) +python main.py --save_dir GOPRO_L1_amp --demo true --demo_input_dir ~/Research/dataset/GOPRO_Large/test/GOPR0384_11_00/blur_gamma --precision half +# multi-GPU (REDS, single precision) +python launch.py --n_GPUs 2 main.py --save_dir REDS_L1 --demo true --demo_input_dir ~/Research/dataset/REDS/test/test_blur --demo_output_dir OUTPUT_DIR_NAME +# multi-GPU (REDS, half precision) +python launch.py --n_GPUs 2 main.py --save_dir REDS_L1 --demo true --demo_input_dir ~/Research/dataset/REDS/test/test_blur --demo_output_dir OUTPUT_DIR_NAME --precision half +``` + +## Differences from the original code + +The default options are different from the original paper. +* RGB range is [0, 255] +* L1 loss (without adversarial loss. Usage possible. See above examples) +* Batch size increased to 16. +* Distributed multi-gpu training is recommended. +* Mixed-precision training enabled. Accuracy not guaranteed. +* SSIM function changed from MATLAB to python + +## SSIM issue + +There are many different SSIM implementations. +In this repository, SSIM metric is based on the following function: +```python +from skimage.metrics import structural_similarity +ssim = structural_similarity(ref_im, res_im, multichannel=True, gaussian_weights=True, use_sample_covariance=False) +``` +`SSIM` class in [src/loss/metric.py](src/loss/metric.py) supports PyTorch. +SSIM function in MATLAB is not correct if applied to RGB images. See [this issue](https://github.com/SeungjunNah/DeepDeblur_release/issues/51) for details. diff --git a/backup/deblur/experiment/.gitignore b/backup/deblur/experiment/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..e73174f63226ea4a748536349a6a41a2286e893a --- /dev/null +++ b/backup/deblur/experiment/.gitignore @@ -0,0 +1 @@ +!.gitignore diff --git a/backup/deblur/experiment/LamRes_L1/args.pt b/backup/deblur/experiment/LamRes_L1/args.pt new file mode 100644 index 0000000000000000000000000000000000000000..1269694cbdeacba33471bfc7bfb2d0c8513e5036 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/args.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0e154b2ce90b76bbd5f59f2467a1d438fc899717b2c283cce9980f094bc745b4 +size 1839 diff --git a/backup/deblur/experiment/LamRes_L1/args.txt b/backup/deblur/experiment/LamRes_L1/args.txt new file mode 100644 index 0000000000000000000000000000000000000000..6126ee2b3302fb4247304cdb41ffa66e276490ff --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/args.txt @@ -0,0 +1,65 @@ +execution at 2020-11-05_23-11-53 +seed: 1604589113 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 2 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 255 +model: RecLamResNet +pretrained: +n_scales: 1 +detach: False +gaussian_pyramid: True +n_resblocks: 19 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 16 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +loss: 1*L1 +metric: PSNR,SSIM +save_dir: ../experiment/LamRes_L1 +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + diff --git a/backup/deblur/experiment/LamRes_L1/loss.pt b/backup/deblur/experiment/LamRes_L1/loss.pt new file mode 100644 index 0000000000000000000000000000000000000000..58ee214403b46e63123f9ccc84679f9407247e18 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/loss.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bbcf780b093445d2501306cfd0d249d7b7e4d3ee3f711bd0a042f6ec4ef197d2 +size 5615 diff --git a/backup/deblur/experiment/LamRes_L1/models/model-10.pt b/backup/deblur/experiment/LamRes_L1/models/model-10.pt new file mode 100644 index 0000000000000000000000000000000000000000..9bb787a1ef83713eea5dc4d7ec8e1a77bc03b040 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/models/model-10.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f8cc33863f8a498591728200530800c0ebf391072baf0d132f3386c797760d8b +size 15350843 diff --git a/backup/deblur/experiment/LamRes_L1/models/model-100.pt b/backup/deblur/experiment/LamRes_L1/models/model-100.pt new file mode 100644 index 0000000000000000000000000000000000000000..ea11ce8acc89c32a3592dacb7dc95bacb56a9803 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/models/model-100.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8b00023bdbc5f49f6b44d3bfc3508dc1254e43ac535f6101576fb8fd9b207664 +size 15350843 diff --git a/backup/deblur/experiment/LamRes_L1/models/model-110.pt b/backup/deblur/experiment/LamRes_L1/models/model-110.pt new file mode 100644 index 0000000000000000000000000000000000000000..4d2282d5925927346ad42ecdba868951c653dc0e --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/models/model-110.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:05a618f083234674d5637e10d440b9900c4d87d8a256bcf98c7a72b924bdae30 +size 15350843 diff --git a/backup/deblur/experiment/LamRes_L1/models/model-120.pt b/backup/deblur/experiment/LamRes_L1/models/model-120.pt new file mode 100644 index 0000000000000000000000000000000000000000..1cbb2aabc79799594f0fb99d24d753c6c3535859 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/models/model-120.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8611132faac7bec4eea21d9a3e7f86208de639b873677693c2666fbe97778a55 +size 15350843 diff --git a/backup/deblur/experiment/LamRes_L1/models/model-130.pt b/backup/deblur/experiment/LamRes_L1/models/model-130.pt new file mode 100644 index 0000000000000000000000000000000000000000..9fb0bb84de00c473111aaf34710f2c41e3808582 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/models/model-130.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4d4ba049d42899538a962f02f0a56bf7226df3289d25cee6c71fa152e797432c +size 15350843 diff --git a/backup/deblur/experiment/LamRes_L1/models/model-140.pt b/backup/deblur/experiment/LamRes_L1/models/model-140.pt new file mode 100644 index 0000000000000000000000000000000000000000..cce97e9903a91cf714a183e8a182c4572e847726 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/models/model-140.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:592143f8ce0d946606da39ef5f2af8af2088c32c80ffeccdc0a177b79da1403e +size 15350843 diff --git a/backup/deblur/experiment/LamRes_L1/models/model-150.pt b/backup/deblur/experiment/LamRes_L1/models/model-150.pt new file mode 100644 index 0000000000000000000000000000000000000000..2560dd98b7a4b69b1f221b9c7e7c28b6d8017944 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/models/model-150.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c947731358d9b59d83641f9525c398b8ab9abbd59b9030287f2d5584ca99be9f +size 15350843 diff --git a/backup/deblur/experiment/LamRes_L1/models/model-160.pt b/backup/deblur/experiment/LamRes_L1/models/model-160.pt new file mode 100644 index 0000000000000000000000000000000000000000..3123e4b7b515b1d3eeb219e657ca7deae8d4960a --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/models/model-160.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f3da488b9ebadd9dbe44bd2095a1312c5a9deb68fb40d87a0769928a8aafd9d5 +size 15350843 diff --git a/backup/deblur/experiment/LamRes_L1/models/model-170.pt b/backup/deblur/experiment/LamRes_L1/models/model-170.pt new file mode 100644 index 0000000000000000000000000000000000000000..a04331f7cf702740e3f4c78568f7039d254e6c85 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/models/model-170.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6baff5c023c9a241ba5103908e59ec7f3758c47564ce5f3a1c456b3b6961549f +size 15350843 diff --git a/backup/deblur/experiment/LamRes_L1/models/model-180.pt b/backup/deblur/experiment/LamRes_L1/models/model-180.pt new file mode 100644 index 0000000000000000000000000000000000000000..3ecaa4e79e690b1ff4d06c9fc70a1e0cbb4635cb --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/models/model-180.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:89674ab744cae258501f1d3f5838f42a5c19f6678128e4f27d25129598853597 +size 15350843 diff --git a/backup/deblur/experiment/LamRes_L1/models/model-190.pt b/backup/deblur/experiment/LamRes_L1/models/model-190.pt new file mode 100644 index 0000000000000000000000000000000000000000..14d9e6435aaf39d84bb232f87e95abcccc93f8c4 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/models/model-190.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:96e3736ce66ee6de19e87c4610096493e008280ade0e2af2da23de0bf87fbcb9 +size 15350843 diff --git a/backup/deblur/experiment/LamRes_L1/models/model-20.pt b/backup/deblur/experiment/LamRes_L1/models/model-20.pt new file mode 100644 index 0000000000000000000000000000000000000000..a745f47fe9fb9e9ce91d40c7de47eade431804a2 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/models/model-20.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eeb1344448aead8916dc8bbc5b294c6bc8e4957f126486f95e008883294e9c73 +size 15350843 diff --git a/backup/deblur/experiment/LamRes_L1/models/model-30.pt b/backup/deblur/experiment/LamRes_L1/models/model-30.pt new file mode 100644 index 0000000000000000000000000000000000000000..038484f3383bb58f7556dba7fe83c477f7f10b81 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/models/model-30.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ef7ea33f7d21e44953c1d501a58952f097ad50c3fd90cae1ce720f2d8508e648 +size 15350843 diff --git a/backup/deblur/experiment/LamRes_L1/models/model-40.pt b/backup/deblur/experiment/LamRes_L1/models/model-40.pt new file mode 100644 index 0000000000000000000000000000000000000000..0fb9d040e6b9fdf54cae494aa181b0ee114f7ee1 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/models/model-40.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f675d487b3be888b33a69a61b566c31024229e99721be30009322774a4071f77 +size 15350843 diff --git a/backup/deblur/experiment/LamRes_L1/models/model-50.pt b/backup/deblur/experiment/LamRes_L1/models/model-50.pt new file mode 100644 index 0000000000000000000000000000000000000000..05cfdfecf30f943afb42629147ec8f4f052c0e2e --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/models/model-50.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:46dad3d499b7c48b6e010fb57286c518811c4dcb3d3cfa988b316ac346de2311 +size 15350843 diff --git a/backup/deblur/experiment/LamRes_L1/models/model-60.pt b/backup/deblur/experiment/LamRes_L1/models/model-60.pt new file mode 100644 index 0000000000000000000000000000000000000000..26ffc7a2f58a23ae0fff12ba0698ef4d8c18af5d --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/models/model-60.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f546724dba8cbeb7f4cff4d3d54dbd441f65c1d8534ba06792755c26f194e843 +size 15350843 diff --git a/backup/deblur/experiment/LamRes_L1/models/model-70.pt b/backup/deblur/experiment/LamRes_L1/models/model-70.pt new file mode 100644 index 0000000000000000000000000000000000000000..1bb9b64f02d181de482976a2a682543bcb8b7ed3 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/models/model-70.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:38e4ffefebbed343533609a7d5da88e5ec1d1fd1492cbd22fc698423d62b887a +size 15350843 diff --git a/backup/deblur/experiment/LamRes_L1/models/model-80.pt b/backup/deblur/experiment/LamRes_L1/models/model-80.pt new file mode 100644 index 0000000000000000000000000000000000000000..0b6bd578e863e9c17cf808473fe967d273b829e5 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/models/model-80.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2de8818386dd6da1bbaa8f47eebdef938f25d3c63484e8b9af4eb9faa8ee89cc +size 15350843 diff --git a/backup/deblur/experiment/LamRes_L1/models/model-90.pt b/backup/deblur/experiment/LamRes_L1/models/model-90.pt new file mode 100644 index 0000000000000000000000000000000000000000..155f973ba3f009828c3371d40081b7babb8114ef --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/models/model-90.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:de94830b770ea3cfc95f6ea405c376d4af930cbee3c377cc2563db8e142a7bb3 +size 15350843 diff --git a/backup/deblur/experiment/LamRes_L1/optim/optim-10.pt b/backup/deblur/experiment/LamRes_L1/optim/optim-10.pt new file mode 100644 index 0000000000000000000000000000000000000000..e20623266c5ee6d4fca60f683edc2894b0cc13f8 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/optim/optim-10.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a15147a92b1e8cc84e929a89f0b5426133e63fa23a50d7ba45f1ad630a0a3cfe +size 30674863 diff --git a/backup/deblur/experiment/LamRes_L1/optim/optim-100.pt b/backup/deblur/experiment/LamRes_L1/optim/optim-100.pt new file mode 100644 index 0000000000000000000000000000000000000000..01f848b35b5b1ee213cb8ee74e04d69daea12e56 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/optim/optim-100.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f9e2f048b0c0bed9a958a424bb6ceaf3958a7f666d1f368c86971922fddc0987 +size 30674863 diff --git a/backup/deblur/experiment/LamRes_L1/optim/optim-110.pt b/backup/deblur/experiment/LamRes_L1/optim/optim-110.pt new file mode 100644 index 0000000000000000000000000000000000000000..04ed9edf2d97d9cbc309957bcacb3213cbfc86f2 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/optim/optim-110.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10ec03ea0789ecc553973714a5e4d8537e991141e579911b5e3d070b4d87aee6 +size 30674863 diff --git a/backup/deblur/experiment/LamRes_L1/optim/optim-120.pt b/backup/deblur/experiment/LamRes_L1/optim/optim-120.pt new file mode 100644 index 0000000000000000000000000000000000000000..950865f1d5dcd7c7b31d47e440d9ffa92a41d703 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/optim/optim-120.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0fc1c8a05bc87113484b86ba7f543631dedeb55e0022a09ec24cad2b0e408b7e +size 30674863 diff --git a/backup/deblur/experiment/LamRes_L1/optim/optim-130.pt b/backup/deblur/experiment/LamRes_L1/optim/optim-130.pt new file mode 100644 index 0000000000000000000000000000000000000000..05fdb0f6ed3eb7e4716ebbdcd5e175810e7cea89 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/optim/optim-130.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:48e84b73c5f0cc0514f02fbf62d1d9b5e09c0c7b233038196214934f8c1bb108 +size 30674863 diff --git a/backup/deblur/experiment/LamRes_L1/optim/optim-140.pt b/backup/deblur/experiment/LamRes_L1/optim/optim-140.pt new file mode 100644 index 0000000000000000000000000000000000000000..98cc0e10e2de33e64cdf5c60c79e5e637f3a1fb4 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/optim/optim-140.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:692152abed37cd77a8577bfcf7d7e7a221fc1de0bbe10092945ff393d02e4e0c +size 30674863 diff --git a/backup/deblur/experiment/LamRes_L1/optim/optim-150.pt b/backup/deblur/experiment/LamRes_L1/optim/optim-150.pt new file mode 100644 index 0000000000000000000000000000000000000000..c4b9715f320ab8f7f013753a478aad1401b06163 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/optim/optim-150.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f9853ac30a95e833871f8d7dc80ff637aae0a52b78f13d29a1e52189ee2ddc20 +size 30674863 diff --git a/backup/deblur/experiment/LamRes_L1/optim/optim-160.pt b/backup/deblur/experiment/LamRes_L1/optim/optim-160.pt new file mode 100644 index 0000000000000000000000000000000000000000..f53ac5653d9cd67fa87860457cafd6c904ee3373 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/optim/optim-160.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9bf7532929704778fbd23e23dff57884762b6644b6fd2e720d0d106c05aa56ad +size 30674863 diff --git a/backup/deblur/experiment/LamRes_L1/optim/optim-170.pt b/backup/deblur/experiment/LamRes_L1/optim/optim-170.pt new file mode 100644 index 0000000000000000000000000000000000000000..8fbadc1f7865e857f24a4e1aced07e507f596eab --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/optim/optim-170.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2061c1061e781e6583237b585ea3fb1f7d95cf1549302616d2eda188a56f4eff +size 30674863 diff --git a/backup/deblur/experiment/LamRes_L1/optim/optim-180.pt b/backup/deblur/experiment/LamRes_L1/optim/optim-180.pt new file mode 100644 index 0000000000000000000000000000000000000000..c4e53509f6fda1cd0d1eea14b2eb691e1c207ed4 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/optim/optim-180.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5982428912e10098ce039f046b630239984b5a1b5156595f2194c5f4eb54d385 +size 30674863 diff --git a/backup/deblur/experiment/LamRes_L1/optim/optim-190.pt b/backup/deblur/experiment/LamRes_L1/optim/optim-190.pt new file mode 100644 index 0000000000000000000000000000000000000000..aed190397569a17f6974fac3a0f8cd4a82e1317c --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/optim/optim-190.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e3e8f9a9ea8eb637bad4550d5ebc1a89e4ba4da3f9f436d9a9f46d12c2915246 +size 30674863 diff --git a/backup/deblur/experiment/LamRes_L1/optim/optim-20.pt b/backup/deblur/experiment/LamRes_L1/optim/optim-20.pt new file mode 100644 index 0000000000000000000000000000000000000000..2591e62a242f112aef491c78a44e7177a69d2221 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/optim/optim-20.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:97fe4a1e0350f73d55bc341b893be3dd1b0c837a5bdd5e7706a07d6b323a1ec4 +size 30674863 diff --git a/backup/deblur/experiment/LamRes_L1/optim/optim-30.pt b/backup/deblur/experiment/LamRes_L1/optim/optim-30.pt new file mode 100644 index 0000000000000000000000000000000000000000..1552c48d098ed3061b6efdeae0fa77c73586f8ba --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/optim/optim-30.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e8bbbfa36c793f302be4db24bc36e4330923fd9c2ae882b75fa93434a343e1e3 +size 30674863 diff --git a/backup/deblur/experiment/LamRes_L1/optim/optim-40.pt b/backup/deblur/experiment/LamRes_L1/optim/optim-40.pt new file mode 100644 index 0000000000000000000000000000000000000000..ac61c5c9f67d7d4aa586b91d380f8da65190cc2d --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/optim/optim-40.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e7018cc1fad92e918c8600624b7ed19c4b61cb5197fa96ce5f3baf018fb4772a +size 30674863 diff --git a/backup/deblur/experiment/LamRes_L1/optim/optim-50.pt b/backup/deblur/experiment/LamRes_L1/optim/optim-50.pt new file mode 100644 index 0000000000000000000000000000000000000000..0f77fdbd87d92a4f6090a7970831feef9dc82419 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/optim/optim-50.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:57f8c05904eff75b27990e33fa77c365a57510dafa3c02546d9a3a8820052c8d +size 30674863 diff --git a/backup/deblur/experiment/LamRes_L1/optim/optim-60.pt b/backup/deblur/experiment/LamRes_L1/optim/optim-60.pt new file mode 100644 index 0000000000000000000000000000000000000000..2da3ea38b530e6f32f08bef3d16a661eeb878bf0 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/optim/optim-60.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3a43321f5d6f3dc3b9f15135e9363441a8dcaaed507ba901cef7635f44f88d82 +size 30674863 diff --git a/backup/deblur/experiment/LamRes_L1/optim/optim-70.pt b/backup/deblur/experiment/LamRes_L1/optim/optim-70.pt new file mode 100644 index 0000000000000000000000000000000000000000..7b510bfbe56c6a7b6147b82ae24f026c29a1cc86 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/optim/optim-70.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0229a056907d2ad115a90eebf4731ba0d1a6291cf850f4c60a5b199ce8967174 +size 30674863 diff --git a/backup/deblur/experiment/LamRes_L1/optim/optim-80.pt b/backup/deblur/experiment/LamRes_L1/optim/optim-80.pt new file mode 100644 index 0000000000000000000000000000000000000000..dee5e497f14727b49b860deff5f554708c723d54 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/optim/optim-80.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e867a2b95f3cc0ef76bfd0a754f95baaf4a6649d9ee149e2a43f8645f46354b9 +size 30674863 diff --git a/backup/deblur/experiment/LamRes_L1/optim/optim-90.pt b/backup/deblur/experiment/LamRes_L1/optim/optim-90.pt new file mode 100644 index 0000000000000000000000000000000000000000..0ff82a08b94c5a6dfb8aed4ab8993b561a416409 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/optim/optim-90.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:55b737a3bee8a0f38fc50e1edafb79c72497f41e3bec24a222ed664ef8f9e8ee +size 30674863 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000001.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000001.png new file mode 100644 index 0000000000000000000000000000000000000000..b8e15e08cde90076085fb2d4864f5ce45ecbcb97 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000001.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000011.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000011.png new file mode 100644 index 0000000000000000000000000000000000000000..62924155dd4ce908b9cadb03c0d0c2b125913bf3 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000011.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000021.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000021.png new file mode 100644 index 0000000000000000000000000000000000000000..21849dfa0e763155c886cf014229d63daff18165 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000021.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000031.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000031.png new file mode 100644 index 0000000000000000000000000000000000000000..e8006dd5d6348a077361004fe65c3bf8baf22954 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000031.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5c083d48348141b9abca21d3d3bb854efae98f49e9571874ee1d1d48edb41c3b +size 1025280 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000041.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000041.png new file mode 100644 index 0000000000000000000000000000000000000000..63be3f002b733eb9a4109c31c64761df2713e7d6 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000041.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7581338bc0ff39ba18f55a836cf80311ffb6af09860ace12337545322be9aacd +size 1014212 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000051.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000051.png new file mode 100644 index 0000000000000000000000000000000000000000..43eabcc8a42a0d016b12ad949f015833520a16b3 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000051.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:387ad62af7c5cc9673cb56d8904bf1c90db0ea7b48627c7cbc452bfa5550ed1e +size 1034629 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000061.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000061.png new file mode 100644 index 0000000000000000000000000000000000000000..0afa2bb7b0bcfe5d1581449a8903a4d06cd291de Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000061.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000071.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000071.png new file mode 100644 index 0000000000000000000000000000000000000000..7bc1b4ff3fdd71c76aa48ca725b5f36a408092c8 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000071.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7bbfe12f8b9fa7c3fcf10ad0b2017803b7be295c7a9ad1f4a3868a6483ee59d9 +size 1050879 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000081.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000081.png new file mode 100644 index 0000000000000000000000000000000000000000..f4a8901aae81dfd3292cecfb725698a138fb00c8 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000081.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000091.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000091.png new file mode 100644 index 0000000000000000000000000000000000000000..fafd2d317d704ee4cc5213d4589c189ec4df6809 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_00/blur_gamma/000091.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:509b08424b1cc570984f88055d57ad4101ee328eab8538e2b32b2c0fda4b6d8e +size 1000117 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004001.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004001.png new file mode 100644 index 0000000000000000000000000000000000000000..780cba8598fed5618737778850033697013685dc Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004001.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004011.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004011.png new file mode 100644 index 0000000000000000000000000000000000000000..6702cb7571ac2eca1c3c3fcbb6d89bd491333674 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004011.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004021.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004021.png new file mode 100644 index 0000000000000000000000000000000000000000..68ee74bac05ae02fa11e6b4dc9c818b797bfa500 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004021.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004031.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004031.png new file mode 100644 index 0000000000000000000000000000000000000000..3c8b5036430063b993377c454f11bc76daaca50e Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004031.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004041.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004041.png new file mode 100644 index 0000000000000000000000000000000000000000..ac4ea7d8c8872d9548d13cca285a3f626d7e0edc Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004041.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004051.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004051.png new file mode 100644 index 0000000000000000000000000000000000000000..4f0e4edf186d6bcbfde8b328bce4d61d95db65a8 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004051.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004061.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004061.png new file mode 100644 index 0000000000000000000000000000000000000000..e6230f2cdffbc0ccdbba56dfbffa1ce38108ed6b Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004061.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004071.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004071.png new file mode 100644 index 0000000000000000000000000000000000000000..e75649c66c6eadd3aecd43f98bf5db86c07a42c2 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004071.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004081.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004081.png new file mode 100644 index 0000000000000000000000000000000000000000..e994f62e94205285f5ccd482967e29e566b20e66 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004081.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004091.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004091.png new file mode 100644 index 0000000000000000000000000000000000000000..6bddb3ff23a817a3c3c9aefaedbad0ddfdd261c8 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0384_11_05/blur_gamma/004091.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e13d19548817ce97b047b8a5cff1605c3fd8689b4903bf0b47c92484ca18dc5e +size 1010488 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003011.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003011.png new file mode 100644 index 0000000000000000000000000000000000000000..e4b9c51ad8b9104cedba031208fe6b27b22a3c91 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003011.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003021.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003021.png new file mode 100644 index 0000000000000000000000000000000000000000..d7ae50a07f79ab230af9fd38828bcd69d9e49d18 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003021.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003031.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003031.png new file mode 100644 index 0000000000000000000000000000000000000000..235cab1d5717ce53078a92bbd36edb421aeb6247 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003031.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003041.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003041.png new file mode 100644 index 0000000000000000000000000000000000000000..fca6a6881daf19b5710f7264fa4650d18f64fb35 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003041.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003051.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003051.png new file mode 100644 index 0000000000000000000000000000000000000000..f059825cbaccbb1c4dd6330f123c1899ab070733 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003051.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003061.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003061.png new file mode 100644 index 0000000000000000000000000000000000000000..248eb7b6e4b9fd16dbf699103470874449cac233 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003061.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003071.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003071.png new file mode 100644 index 0000000000000000000000000000000000000000..dcf334aca96d578ca3248aaa014e4828026d8440 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003071.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003081.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003081.png new file mode 100644 index 0000000000000000000000000000000000000000..3b42b81139be7ed69e0e1632711e3450a124e86b Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003081.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003091.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003091.png new file mode 100644 index 0000000000000000000000000000000000000000..2222b7d2f59b4b771e6bae0839fdad0a9184c04e Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003091.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003101.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003101.png new file mode 100644 index 0000000000000000000000000000000000000000..7c818f83c9289c6d77f763f53d78a642d718b75e Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0385_11_01/blur_gamma/003101.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000001.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000001.png new file mode 100644 index 0000000000000000000000000000000000000000..c8f613660f272161df7557fc91dce08ee87710fb --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000001.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:78fa3230f2038cd3e6cb3288f2ef179cad8a2691725ed19bb669cce6f2d4ba2e +size 1422378 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000011.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000011.png new file mode 100644 index 0000000000000000000000000000000000000000..d03fd850c8ce5b04d029ab7e2989b94001d092f8 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000011.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:318f59559aab6aaa55c23d02ded18b27df7be212a75240c46fc9ef90ee1432d6 +size 1444867 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000021.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000021.png new file mode 100644 index 0000000000000000000000000000000000000000..1f98ad2b773a46ed68c2d5e71d4cc125a6e17ef8 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000021.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:67724112448cf3a504487c6f7f5c006a07fb0e8f46a156b22f45a9235ae7befd +size 1450578 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000031.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000031.png new file mode 100644 index 0000000000000000000000000000000000000000..9201e2e33b7982bb879d3f00e719651ec601ab5d --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000031.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:72e049a08580f7d801ffdc449422f0ef0e1e1e26b112056f14b95146b65bda58 +size 1466214 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000041.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000041.png new file mode 100644 index 0000000000000000000000000000000000000000..dfded4d51f691b5716af96c1cbb7b783a1a43bfb --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000041.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:67cdacf4dfda717c35e84899bf1773552f6b025dd0033724468f2de355d6e478 +size 1460852 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000051.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000051.png new file mode 100644 index 0000000000000000000000000000000000000000..b09aff17e03455e93bde8713ca3424b9dee6b172 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000051.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d64f892a4ee58469d8492368335de8a4dea40654f294ca1a3ed0b037cc27ff60 +size 1481038 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000061.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000061.png new file mode 100644 index 0000000000000000000000000000000000000000..bf47d652f19712ed07050d088fe20d0de6865995 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000061.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d0454d7d65f093c8c7ee8b52ab30309aebd463ba85f14a223dad5b1fd6207ef1 +size 1500885 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000071.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000071.png new file mode 100644 index 0000000000000000000000000000000000000000..7a8be5c716b6c4ca5a56f36245d9030e47573d1a --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000071.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4af8eab4a76d7d8c58565ba5714b2f2033a86c2cf17c4a9561800d342475b15f +size 1466841 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000081.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000081.png new file mode 100644 index 0000000000000000000000000000000000000000..68146fa564d8900f579a4c2113314607e7ee6d04 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000081.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7239aac7a3378330b4c319e22a5a612bd370a06911afee9a709ca0ce546df278 +size 1544936 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000091.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000091.png new file mode 100644 index 0000000000000000000000000000000000000000..93ca07a07a72807ed5a5aca4b3a62d31c33ac07c --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0396_11_00/blur_gamma/000091.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c57c2f37b9e8f9cf6695cabbb7cdf94364568b6c4cf3abec1d219a968fdc9b5f +size 1489807 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000101.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000101.png new file mode 100644 index 0000000000000000000000000000000000000000..1fd8a9ed9bb74f9da77a23808fbaeae7b711349f Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000101.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000111.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000111.png new file mode 100644 index 0000000000000000000000000000000000000000..2e20dfcd16099cd40c7d2234649d86529c71f581 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000111.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000121.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000121.png new file mode 100644 index 0000000000000000000000000000000000000000..0d0449f6302ce06a5170e5585e9480eb81ad9844 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000121.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000131.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000131.png new file mode 100644 index 0000000000000000000000000000000000000000..00e804d62d018646b008e82b7248220af657377e Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000131.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000141.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000141.png new file mode 100644 index 0000000000000000000000000000000000000000..8d3f214a86d285106ce8a4746fb380c544b00c16 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000141.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000151.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000151.png new file mode 100644 index 0000000000000000000000000000000000000000..7199f12b7c24c423109c2a62f3ed1f24ff786d39 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000151.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000161.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000161.png new file mode 100644 index 0000000000000000000000000000000000000000..0dc768c40d1ca195887ec5f0948b39b97fda9597 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000161.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000171.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000171.png new file mode 100644 index 0000000000000000000000000000000000000000..d7ffb9898a72874cff28de4fa47c71c1adce1f61 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000171.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000181.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000181.png new file mode 100644 index 0000000000000000000000000000000000000000..5fb060455d06ad989e02ed903f4634d3809f4bad Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000181.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000191.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000191.png new file mode 100644 index 0000000000000000000000000000000000000000..4f591bed523c0ad1acf2f01f15a351e0759f730b Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000191.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000201.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000201.png new file mode 100644 index 0000000000000000000000000000000000000000..15e0532d6790c0f57baf2cf786ca4b74c69ed65f Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000201.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000211.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000211.png new file mode 100644 index 0000000000000000000000000000000000000000..035370dc5fafcdfab5bfbf1b616edae1926ae033 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000211.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000221.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000221.png new file mode 100644 index 0000000000000000000000000000000000000000..d824166ea5a2478958704937ad1d77ca2b89a7ec Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000221.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000231.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000231.png new file mode 100644 index 0000000000000000000000000000000000000000..2901f082cc4c0ffb2cf8ebe5cd523e67a480bb46 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0410_11_00/blur_gamma/000231.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000007.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000007.png new file mode 100644 index 0000000000000000000000000000000000000000..2bf5cfc77c84567f4c76fbc17c927469e5265a3a --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000007.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:78de6dc2b346cdc8d9e02a2c9e57494df07851dc572a802ffd7da13bdedfa8bd +size 1008186 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000017.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000017.png new file mode 100644 index 0000000000000000000000000000000000000000..29dffe8a349e15ff12d73eb45568c50dfe9965c7 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000017.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9e5ef9bd00a817ccea381140d8e577a69328225a917a04675b94af2041b2c78a +size 1080688 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000027.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000027.png new file mode 100644 index 0000000000000000000000000000000000000000..f0fd5e57e4e3e557b5f8bc4cc469161be56aa0cf Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000027.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000037.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000037.png new file mode 100644 index 0000000000000000000000000000000000000000..67eead943df9daef4eaac7397001fa7ed5d28568 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000037.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a5b0406a4b4d2ed99724202b2b41850433fcc465d61afb0987f7edec32e34e2e +size 1127363 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000047.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000047.png new file mode 100644 index 0000000000000000000000000000000000000000..cabd0042b85c6e3d9c0acbd8f2f3498c27892299 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000047.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4e473d1fe397b4343ecaa89d63f51da0c36fedb74d2d183a0b941614fa907878 +size 1071926 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000057.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000057.png new file mode 100644 index 0000000000000000000000000000000000000000..f476f3bf680ef753b8dc7f00fa37affd38f4e28f --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000057.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bd0b960d1cc67d3e5777677e75ff7f8eb2d32d613693a0f661fc0651924e5dd0 +size 1067587 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000067.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000067.png new file mode 100644 index 0000000000000000000000000000000000000000..a916380c4a74dfa704cd6fcfe117e70d7e5dad69 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000067.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a16c545e394ce1424236687287f1e38255210a7d441cab7e92df17aaf71f8950 +size 1142943 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000077.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000077.png new file mode 100644 index 0000000000000000000000000000000000000000..6fd77f9850156e5230b29c37f9e4b8f1ad19785e --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000077.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:83d54da541555fa58ad1b0e3bd1c3a1d02816e4e64fc584490ff564259ef5207 +size 1116848 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000087.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000087.png new file mode 100644 index 0000000000000000000000000000000000000000..652b8b14473d38148e6c1348f4bbcf94c5659bd0 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000087.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6d9ac08a908363a9385296e561f8d40dcf86003f828ea416140b08c2cccb12e3 +size 1099517 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000097.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000097.png new file mode 100644 index 0000000000000000000000000000000000000000..225b89c0d188d0740a45d6709a796249fcd7aa89 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0854_11_00/blur_gamma/000097.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3759ab6bc4500be3a60e4247fe131bf38c9aac6e17e85a110b02f8fc5b94695e +size 1004716 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000007.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000007.png new file mode 100644 index 0000000000000000000000000000000000000000..44e204143a64bbe2752504a154899c29094169dc --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000007.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:13d8f8f002a0c8ecb31145b93191e325baa9c82b65916e74e74c34f8db81eeea +size 1209384 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000017.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000017.png new file mode 100644 index 0000000000000000000000000000000000000000..de7410f9240d21f025493499e046329a2d1a4213 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000017.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:411712064952bc3ec953aa880daadbdd9a2e90532228996a0df7d6eb19020794 +size 1094203 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000027.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000027.png new file mode 100644 index 0000000000000000000000000000000000000000..e8286a2a741d16f2d9bd15b705d9e7a2b491fb42 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000027.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:94f5ba30dfeccc5053728f168b41e91c45d43ae6009acebfac2f6aad8f7a3f37 +size 1146605 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000037.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000037.png new file mode 100644 index 0000000000000000000000000000000000000000..fd1d5317bbdddefec3770a4bd2927c4efac91b3f --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000037.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2ad8ffa0355161cefb8c3341919dfed8e930ac5e0b794f54c41dd7ec3d0bcd5c +size 1142071 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000047.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000047.png new file mode 100644 index 0000000000000000000000000000000000000000..1cda8193337922d493e0e29ff660b516fe88718b --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000047.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:139fea86cdcccac5d5f9128faab75453e2dabfe803891b9d2eae314b7c2e7ea7 +size 1273529 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000057.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000057.png new file mode 100644 index 0000000000000000000000000000000000000000..0d3bff3a89ae9d377ebea40e297b41bbbcdd494d --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000057.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:82ce3faee9ca4a5760972f07ed6f6aba397429a01131c1ce061434a9cffac98a +size 1146342 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000067.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000067.png new file mode 100644 index 0000000000000000000000000000000000000000..25240d8db5c74d9a7b69d8fc9f5f99e382df74c8 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000067.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1ff3733ce18b9dedf385ac4cd1689d55fd2e75ce252381b042a58dfb5cd7ed89 +size 1099417 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000077.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000077.png new file mode 100644 index 0000000000000000000000000000000000000000..f789f8b6e1525549b8ef1f25fde4494441c10668 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0862_11_00/blur_gamma/000077.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:15dec8c4fa72389ec4cc7e5d0f8fd84a381c3cbe98bf2fc076c8b13d976ee7a0 +size 1197529 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000010.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000010.png new file mode 100644 index 0000000000000000000000000000000000000000..41accbc4bc33665773aeca12fb223ce31682346a --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000010.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3eb7fd7e29bbcaca200bae335d63e9844cfd27b030838b3831e4ca82d3ee98bb +size 1217935 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000020.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000020.png new file mode 100644 index 0000000000000000000000000000000000000000..d5b76174428ab50193f1ef300c0f409d4e48f696 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000020.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d546a895d873fd464f78004ddc8ad96d7387a1b33b0950f3945d7ca84d31fed9 +size 1189764 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000030.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000030.png new file mode 100644 index 0000000000000000000000000000000000000000..1a03f9ccb3c8c97637786399310ad1e0cfbf863f Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000030.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000040.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000040.png new file mode 100644 index 0000000000000000000000000000000000000000..3e701897c2482f4051e730ba1154c5e752038964 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000040.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4facd366aa3d100d6763e7abcb49d1ac85d77f290a1725d27df6384d4bd80d6d +size 1024774 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000050.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000050.png new file mode 100644 index 0000000000000000000000000000000000000000..0cb5890a1c6501dfcbacf830a55577a7411255a7 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000050.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2d97ae6a2018e2d007b61148ef9c0fd2c3337e3dff58d4fdc704b6be9e029a47 +size 1171953 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000060.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000060.png new file mode 100644 index 0000000000000000000000000000000000000000..b435bd486eea79947cbfa0fbbc635d5fd0a5ed9c --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000060.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4f01ac694604f6f56b9348f17dc45e25a97a8219969f7fa22e90d437789ac293 +size 1099421 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000070.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000070.png new file mode 100644 index 0000000000000000000000000000000000000000..2f367317ab06e559d0d8f636dfe70b77a5dccb37 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000070.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8adeb71dcd59026af07cffd9d8e37745d3cd7a68cf13d35a429d27b6a80a7f51 +size 1161828 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000080.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000080.png new file mode 100644 index 0000000000000000000000000000000000000000..0b5d40429500dbfddd1303c13d0da0bef6309801 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000080.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eae67de1a5050421b247ca3fcf4229613e17630007406bcec67ac8232a2444b9 +size 1140991 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000090.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000090.png new file mode 100644 index 0000000000000000000000000000000000000000..94b53fcc69ec9f0e6307886a085c138f8d34a2a0 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000090.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000100.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000100.png new file mode 100644 index 0000000000000000000000000000000000000000..b2c2b4a470e95823b4139d08298a3e15c0ac073f --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0868_11_00/blur_gamma/000100.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:50770362dcc926f077ab0a399fb3d93c3f0a83ea0eaddd62b58c241709cc85df +size 1076473 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000010.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000010.png new file mode 100644 index 0000000000000000000000000000000000000000..a7fe7cfe2386138bbe807d1a77c3cbaa226067d6 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000010.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000020.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000020.png new file mode 100644 index 0000000000000000000000000000000000000000..7d63cb7e06ebc493111862c2e9aa5ce83c67bf67 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000020.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000030.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000030.png new file mode 100644 index 0000000000000000000000000000000000000000..165f193fbf15da8e36dc720311aeb0e0d5dbacf5 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000030.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000040.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000040.png new file mode 100644 index 0000000000000000000000000000000000000000..d5efd9474a58e6ffcb6d47f9e0decbbafe9b84a3 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000040.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3a044245f64bb2e3dbce16ff9450026a5218fcf912309aebe781756b7a6bbea2 +size 1008561 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000050.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000050.png new file mode 100644 index 0000000000000000000000000000000000000000..6be026bb63a90c5e708c98e3b6787b966b8f83a4 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000050.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7229bd8ca91d90541ef860fd09cc2aa0076aa5a77929f29b33efd3368336fa05 +size 1158265 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000060.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000060.png new file mode 100644 index 0000000000000000000000000000000000000000..295428f17b22744ffcadb8a619546a7eaedec8e2 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000060.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ad20519b27f6ff4896e07c23e1c5fa7a38ce07961252becf971a4f78464bdf42 +size 1048712 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000070.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000070.png new file mode 100644 index 0000000000000000000000000000000000000000..637dbd2c164ef50f9d9087e2142614c3466d08c8 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000070.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bbf8c1fe089e1ddc6988758943c75044b8005f9c515feb81653f7ce06c0450d4 +size 1040558 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000080.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000080.png new file mode 100644 index 0000000000000000000000000000000000000000..738369b835577ff63ddcfa929026ca03e2806669 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000080.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000090.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000090.png new file mode 100644 index 0000000000000000000000000000000000000000..72477848acf764ca9d11a795b9cacbd3bf64c3a3 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000090.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000100.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000100.png new file mode 100644 index 0000000000000000000000000000000000000000..3c30c4e08b67d4f3d7f9ae3d37e97efc1af0ea1e --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0869_11_00/blur_gamma/000100.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6f80517d8157b5dfe611883ee89d6e4a186ab89f6454dd307d7911db0953c294 +size 1129102 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000010.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000010.png new file mode 100644 index 0000000000000000000000000000000000000000..b85dfb42c945cf9d311798d3c898290e6fc485f5 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000010.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000020.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000020.png new file mode 100644 index 0000000000000000000000000000000000000000..051f3b26c428aef3cecb7e53c68225ab8936b2c9 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000020.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f29050bad474a97b35ce9efd0898961075930bc0ac032d4fd9d6d07a439eb641 +size 1188815 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000030.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000030.png new file mode 100644 index 0000000000000000000000000000000000000000..c866adc0536de471ad8aaa01d22bcf75913013f6 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000030.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7f93aa2990d855c24b3b3982fc23d8a69865600986e32c0f6008654344bcb444 +size 1096184 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000040.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000040.png new file mode 100644 index 0000000000000000000000000000000000000000..20fbb81ffa8f8dddac0b754a25a4637ddfd75e80 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000040.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:995ba75e192120830d43508082fe8e856a3711eb1882fc0142aaeb48ca56b6ec +size 1005307 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000050.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000050.png new file mode 100644 index 0000000000000000000000000000000000000000..6a4cd597590a0b2c3f17634382ca497ed11a04e7 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000050.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:92959abbf3c219ed43a72727603aa50b3bf46981e10e999518468c218ff51558 +size 1022711 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000060.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000060.png new file mode 100644 index 0000000000000000000000000000000000000000..a0f03a27373bad073ef755e186090b272ac152a0 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000060.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4785994076d3938637c8ce0935f0f7c823bcebfdf5f838c3182601c93c8e2dcf +size 1118580 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000070.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000070.png new file mode 100644 index 0000000000000000000000000000000000000000..a605bca0c5d81ea2184992af6ad1fae5541aecf3 --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000070.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c187a03280b6f0a4c6e53ccbedc06aba9e6681b6c3999bea634b4719b127aa2 +size 1060002 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000080.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000080.png new file mode 100644 index 0000000000000000000000000000000000000000..0592ef754b3db368c05d20d712ea2d99893aacfe --- /dev/null +++ b/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000080.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:67ce17163c4fbcd7a3d34de79f82d5185e3cf0f6fb49412a88484048e6e1ea3b +size 1017467 diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000090.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000090.png new file mode 100644 index 0000000000000000000000000000000000000000..2ec083ed712a49568195c273bd22f209825f8ff9 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000090.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000100.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000100.png new file mode 100644 index 0000000000000000000000000000000000000000..4c1e10ca928d6ff33e9f121fdd3696bc421990f6 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0871_11_00/blur_gamma/000100.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000210.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000210.png new file mode 100644 index 0000000000000000000000000000000000000000..9c9fda2cbbca34ecb1761a91848ef435da10b2e3 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000210.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000220.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000220.png new file mode 100644 index 0000000000000000000000000000000000000000..6bc03bc52ef22a849836461f8d06d1d267c2ffa8 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000220.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000230.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000230.png new file mode 100644 index 0000000000000000000000000000000000000000..f7782ccd7f8543a0d577a8b3a4d02107844adca5 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000230.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000240.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000240.png new file mode 100644 index 0000000000000000000000000000000000000000..c08dae562f1702b9c2215b2eba207f8f3d9e5805 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000240.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000250.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000250.png new file mode 100644 index 0000000000000000000000000000000000000000..8685b7526f24165c224a003a8718e53c2da6a382 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000250.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000260.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000260.png new file mode 100644 index 0000000000000000000000000000000000000000..e958a1ca5ee3de002a5b9a6a4aeee5add14adf4c Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000260.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000270.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000270.png new file mode 100644 index 0000000000000000000000000000000000000000..65023aa0d38c5e38c70ce5a6b3a99ddc2224cd01 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000270.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000280.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000280.png new file mode 100644 index 0000000000000000000000000000000000000000..50c7ac00e8a724a59a53db21f561544c74f03404 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000280.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000290.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000290.png new file mode 100644 index 0000000000000000000000000000000000000000..4e85525643993f6f4cb0c4f199dac5abbe5fd173 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000290.png differ diff --git a/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000300.png b/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000300.png new file mode 100644 index 0000000000000000000000000000000000000000..72dc7070b98a8c8352da5b1f394f701476b00d76 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/result/GOPR0881_11_01/blur_gamma/000300.png differ diff --git a/backup/deblur/experiment/LamRes_L1/test_loss.pdf b/backup/deblur/experiment/LamRes_L1/test_loss.pdf new file mode 100644 index 0000000000000000000000000000000000000000..648400592546e036f6fe0303fa9571fc189bd166 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/test_loss.pdf differ diff --git a/backup/deblur/experiment/LamRes_L1/test_metric.pdf b/backup/deblur/experiment/LamRes_L1/test_metric.pdf new file mode 100644 index 0000000000000000000000000000000000000000..39453c02f4ac58ebe41cf601059eae1ed94ef717 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/test_metric.pdf differ diff --git a/backup/deblur/experiment/LamRes_L1/train_loss.pdf b/backup/deblur/experiment/LamRes_L1/train_loss.pdf new file mode 100644 index 0000000000000000000000000000000000000000..4eab598d4c5ba783a90de4e45e179f878f925f95 Binary files /dev/null and b/backup/deblur/experiment/LamRes_L1/train_loss.pdf differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6/args.pt b/backup/deblur/experiment/RAFTNET_L1_R6/args.pt new file mode 100644 index 0000000000000000000000000000000000000000..3b34df6eb07581b7c34d7d28b9262d59420c3679 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6/args.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:991871847b8954b25564bc1b0d84401ea29be0664c5b59d9fc676242e1892821 +size 1903 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6/args.txt b/backup/deblur/experiment/RAFTNET_L1_R6/args.txt new file mode 100644 index 0000000000000000000000000000000000000000..0822f4df4d0f3e9eb26d0b78957d451e880126ac --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6/args.txt @@ -0,0 +1,335 @@ +execution at 2020-11-09_23-02-46 +seed: 1604934166 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 4 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNet +pretrained: +n_scales: 6 +detach: False +gaussian_pyramid: True +n_resblocks: 16 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: False +init_scale: 1024.0 +patch_size: 256 +batch_size: 16 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 1.0 +loss: 1*L1 +metric: PSNR,SSIM +decay_gamma: 0.6 +save_dir: ../experiment/RAFTNET_L1_R6 +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-09_23-05-29 +seed: 1604934329 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 4 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNet +pretrained: +n_scales: 6 +detach: False +gaussian_pyramid: True +n_resblocks: 16 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: False +init_scale: 1024.0 +patch_size: 256 +batch_size: 16 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 1.0 +loss: 1*L1 +metric: PSNR,SSIM +decay_gamma: 0.6 +save_dir: ../experiment/RAFTNET_L1_R6 +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-09_23-08-24 +seed: 1604934504 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 4 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNet +pretrained: +n_scales: 6 +detach: False +gaussian_pyramid: True +n_resblocks: 16 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: False +init_scale: 1024.0 +patch_size: 256 +batch_size: 8 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 1.0 +loss: 1*L1 +metric: PSNR,SSIM +decay_gamma: 0.6 +save_dir: ../experiment/RAFTNET_L1_R6 +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-09_23-09-58 +seed: 1604934598 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 4 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNet +pretrained: +n_scales: 6 +detach: False +gaussian_pyramid: True +n_resblocks: 16 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: False +init_scale: 1024.0 +patch_size: 256 +batch_size: 4 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 1.0 +loss: 1*L1 +metric: PSNR,SSIM +decay_gamma: 0.6 +save_dir: ../experiment/RAFTNET_L1_R6 +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-09_23-11-58 +seed: 1604934718 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 4 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNet +pretrained: +n_scales: 6 +detach: False +gaussian_pyramid: True +n_resblocks: 16 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 8 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 1.0 +loss: 1*L1 +metric: PSNR,SSIM +decay_gamma: 0.6 +save_dir: ../experiment/RAFTNET_L1_R6 +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_rtx/args.pt b/backup/deblur/experiment/RAFTNET_L1_R6_rtx/args.pt new file mode 100644 index 0000000000000000000000000000000000000000..a5b7ffffc34fa9e92dc9abca293a0fe3c505c8ad --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_rtx/args.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1572eee9012c1b4ea089a912db04cddc209708485e711aa9dcecfcfac4e23cd2 +size 1903 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_rtx/args.txt b/backup/deblur/experiment/RAFTNET_L1_R6_rtx/args.txt new file mode 100644 index 0000000000000000000000000000000000000000..7f2bedacbc73222e6cb0473683ff10458b8289f8 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_rtx/args.txt @@ -0,0 +1,402 @@ +execution at 2020-11-09_23-46-07 +seed: 1604936767 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 2 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNets +pretrained: +n_scales: 10 +detach: False +gaussian_pyramid: True +n_resblocks: 10 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: False +init_scale: 1024.0 +patch_size: 256 +batch_size: 16 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 2.0 +loss: 1*MSE +metric: PSNR,SSIM +decay_gamma: 0.5 +save_dir: ../experiment/RAFTNET_L1_R6_rtx +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-09_23-49-50 +seed: 1604936990 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 2 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNets +pretrained: +n_scales: 10 +detach: False +gaussian_pyramid: True +n_resblocks: 10 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: False +init_scale: 1024.0 +patch_size: 256 +batch_size: 16 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 2.0 +loss: 1*MSE +metric: PSNR,SSIM +decay_gamma: 0.5 +save_dir: ../experiment/RAFTNET_L1_R6_rtx +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-09_23-52-49 +seed: 1604937169 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 2 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNets +pretrained: +n_scales: 10 +detach: False +gaussian_pyramid: True +n_resblocks: 10 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: False +init_scale: 1024.0 +patch_size: 256 +batch_size: 16 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 2.0 +loss: 1*MSE +metric: PSNR,SSIM +decay_gamma: 0.5 +save_dir: ../experiment/RAFTNET_L1_R6_rtx +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-09_23-54-42 +seed: 1604937282 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 2 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNets +pretrained: +n_scales: 10 +detach: False +gaussian_pyramid: True +n_resblocks: 10 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 16 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 2.0 +loss: 1*MSE +metric: PSNR,SSIM +decay_gamma: 0.5 +save_dir: ../experiment/RAFTNET_L1_R6_rtx +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-09_23-55-33 +seed: 1604937333 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 2 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNets +pretrained: +n_scales: 10 +detach: False +gaussian_pyramid: True +n_resblocks: 10 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 12 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 2.0 +loss: 1*MSE +metric: PSNR,SSIM +decay_gamma: 0.5 +save_dir: ../experiment/RAFTNET_L1_R6_rtx +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-09_23-56-32 +seed: 1604937392 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 2 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNets +pretrained: +n_scales: 10 +detach: False +gaussian_pyramid: True +n_resblocks: 10 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 8 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 2.0 +loss: 1*MSE +metric: PSNR,SSIM +decay_gamma: 0.5 +save_dir: ../experiment/RAFTNET_L1_R6_rtx +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/args.pt b/backup/deblur/experiment/RAFTNET_L1_R6_test/args.pt new file mode 100644 index 0000000000000000000000000000000000000000..8a2924f55c25e9be978039a095d33cbee0ed9362 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/args.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:054b1a6d2d5592a58d79cffeecda57652bee49304dfb3bbb2f56dbec954ce454 +size 1903 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/args.txt b/backup/deblur/experiment/RAFTNET_L1_R6_test/args.txt new file mode 100644 index 0000000000000000000000000000000000000000..1d66418bb1c16b38673cca0788c053dc34958352 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/args.txt @@ -0,0 +1,737 @@ +execution at 2020-11-09_23-25-07 +seed: 1604935507 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 4 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNet +pretrained: +n_scales: 6 +detach: False +gaussian_pyramid: True +n_resblocks: 10 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: False +init_scale: 1024.0 +patch_size: 256 +batch_size: 16 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 1.0 +loss: 1*L1 +metric: PSNR,SSIM +decay_gamma: 0.6 +save_dir: ../experiment/RAFTNET_L1_R6_test +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-09_23-26-10 +seed: 1604935570 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 4 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNet +pretrained: +n_scales: 6 +detach: False +gaussian_pyramid: True +n_resblocks: 10 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 16 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 1.0 +loss: 1*L1 +metric: PSNR,SSIM +decay_gamma: 0.5 +save_dir: ../experiment/RAFTNET_L1_R6_test +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-09_23-26-39 +seed: 1604935599 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 4 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNet +pretrained: +n_scales: 6 +detach: False +gaussian_pyramid: True +n_resblocks: 10 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 12 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 1.0 +loss: 1*L1 +metric: PSNR,SSIM +decay_gamma: 0.5 +save_dir: ../experiment/RAFTNET_L1_R6_test +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-09_23-27-35 +seed: 1604935655 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 4 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNet +pretrained: +n_scales: 6 +detach: False +gaussian_pyramid: True +n_resblocks: 10 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 12 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 1.0 +loss: 1*L1 +metric: PSNR,SSIM +decay_gamma: 0.5 +save_dir: ../experiment/RAFTNET_L1_R6_test +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-09_23-29-16 +seed: 1604935756 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 4 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNet +pretrained: +n_scales: 6 +detach: False +gaussian_pyramid: True +n_resblocks: 10 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 12 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 1.0 +loss: 1*L1 +metric: PSNR,SSIM +decay_gamma: 0.5 +save_dir: ../experiment/RAFTNET_L1_R6_test +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-09_23-30-15 +seed: 1604935815 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 4 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNet +pretrained: +n_scales: 6 +detach: False +gaussian_pyramid: True +n_resblocks: 10 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 12 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 1.0 +loss: 1*L1 +metric: PSNR,SSIM +decay_gamma: 0.5 +save_dir: ../experiment/RAFTNET_L1_R6_test +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-09_23-30-56 +seed: 1604935856 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 4 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 255 +model: RaftNet +pretrained: +n_scales: 6 +detach: False +gaussian_pyramid: True +n_resblocks: 10 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 12 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 1.0 +loss: 1*L1 +metric: PSNR,SSIM +decay_gamma: 0.5 +save_dir: ../experiment/RAFTNET_L1_R6_test +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-09_23-31-25 +seed: 1604935885 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 4 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNet +pretrained: +n_scales: 6 +detach: False +gaussian_pyramid: True +n_resblocks: 10 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 12 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 1.0 +loss: 1*L1 +metric: PSNR,SSIM +decay_gamma: 0.5 +save_dir: ../experiment/RAFTNET_L1_R6_test +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-09_23-31-42 +seed: 1604935902 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 4 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNet +pretrained: +n_scales: 6 +detach: False +gaussian_pyramid: True +n_resblocks: 10 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 12 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 1.0 +loss: 1*L1 +metric: PSNR,SSIM +decay_gamma: 0.5 +save_dir: ../experiment/RAFTNET_L1_R6_test +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-09_23-32-32 +seed: 1604935952 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 4 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 255 +model: RaftNet +pretrained: +n_scales: 6 +detach: False +gaussian_pyramid: True +n_resblocks: 10 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 12 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 0 +loss: 1*L1 +metric: PSNR,SSIM +decay_gamma: 0.5 +save_dir: ../experiment/RAFTNET_L1_R6_test +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-09_23-33-11 +seed: 1604935991 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 4 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 255 +model: RaftNet +pretrained: +n_scales: 6 +detach: False +gaussian_pyramid: True +n_resblocks: 10 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 12 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 0 +loss: 1*L1 +metric: PSNR,SSIM +decay_gamma: 0.5 +save_dir: ../experiment/RAFTNET_L1_R6_test +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/loss.pt b/backup/deblur/experiment/RAFTNET_L1_R6_test/loss.pt new file mode 100644 index 0000000000000000000000000000000000000000..5a4c89a45438136d9758a83c55d3ccd936ea6f2c --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/loss.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:769f122821c091e89ed958705f09e302d0866dff774bc36c8082fb4011174507 +size 1135 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/models/model-10.pt b/backup/deblur/experiment/RAFTNET_L1_R6_test/models/model-10.pt new file mode 100644 index 0000000000000000000000000000000000000000..0636e2bd259de8ceb6a4103186fb87757ba58d3f --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/models/model-10.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:06bcba8d1ae23cf3b23255800a8db9aabf829db7c074516223ba314e9eed6108 +size 14360454 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/models/model-20.pt b/backup/deblur/experiment/RAFTNET_L1_R6_test/models/model-20.pt new file mode 100644 index 0000000000000000000000000000000000000000..264f577adaccf237300d989afd9518976f360cf1 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/models/model-20.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:92962a33a649e7f9cb448eb1d92e9121bc8a558118978d4b0add2642ef55795f +size 14360454 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/optim/optim-10.pt b/backup/deblur/experiment/RAFTNET_L1_R6_test/optim/optim-10.pt new file mode 100644 index 0000000000000000000000000000000000000000..34a62123d33e44b38dee0498d17c9a0a951b71f6 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/optim/optim-10.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:aaedc962b132f377ea9e879a65001626c40a8c262a784113eb85b5e7155d9cdc +size 28705393 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/optim/optim-20.pt b/backup/deblur/experiment/RAFTNET_L1_R6_test/optim/optim-20.pt new file mode 100644 index 0000000000000000000000000000000000000000..7197615a728fc2969f7449466bfde088b1418b9d --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/optim/optim-20.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dc5885c41dd94996ba6ab75eb6f5a2b34c5c6ee3fd71cee78d02aad66b962fb8 +size 28705393 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000001.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000001.png new file mode 100644 index 0000000000000000000000000000000000000000..15ae152c050227429ed643f314cf1d2915d86618 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000001.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000011.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000011.png new file mode 100644 index 0000000000000000000000000000000000000000..d69758ccfc866fc682c822f40c7b28ed72faee99 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000011.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000021.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000021.png new file mode 100644 index 0000000000000000000000000000000000000000..205f0a40c6bc420c453acf3f13ece1c8ea5956c3 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000021.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000031.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000031.png new file mode 100644 index 0000000000000000000000000000000000000000..923e098f48fddcef5a1f6538899904a37c26c0b0 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000031.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000041.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000041.png new file mode 100644 index 0000000000000000000000000000000000000000..12cb82636f3030a2e2d14408b80c147bedc8caf6 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000041.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000051.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000051.png new file mode 100644 index 0000000000000000000000000000000000000000..f3e614632d98d9bdc9d8a0b50e69ba2feeb338de Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000051.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000061.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000061.png new file mode 100644 index 0000000000000000000000000000000000000000..9083b686a933fe4f27b96c08014ffe9b3a67b820 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000061.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000071.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000071.png new file mode 100644 index 0000000000000000000000000000000000000000..6f8f2377f7c9fdd7dbf7a7a61ef4b4b3a9056852 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000071.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000081.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000081.png new file mode 100644 index 0000000000000000000000000000000000000000..a167d6dfd04d02136021d972341cbb6f4948b173 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000081.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000091.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000091.png new file mode 100644 index 0000000000000000000000000000000000000000..c6843bf68069ba51dbd8d0f6230b05dfbeffb12d Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_00/blur_gamma/000091.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004001.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004001.png new file mode 100644 index 0000000000000000000000000000000000000000..57d0f3e71db6a27966e1b3b3c6cac990f3e421df Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004001.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004011.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004011.png new file mode 100644 index 0000000000000000000000000000000000000000..78feaa674e8599e1e7b50fdb2e61570526e5c7df Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004011.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004021.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004021.png new file mode 100644 index 0000000000000000000000000000000000000000..7644738a260542cea51adf01299145565991b526 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004021.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004031.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004031.png new file mode 100644 index 0000000000000000000000000000000000000000..cecabcd0782572534a1537e9cba2a0018f08c240 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004031.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004041.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004041.png new file mode 100644 index 0000000000000000000000000000000000000000..36a2d615a07f25d2b7f219669524ac680b394356 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004041.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004051.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004051.png new file mode 100644 index 0000000000000000000000000000000000000000..5be58e3656802450b919495f30e0e579ee3d7ba4 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004051.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004061.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004061.png new file mode 100644 index 0000000000000000000000000000000000000000..1f49bf9cf911b86ea930aa7ca281f921ef57321f Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004061.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004071.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004071.png new file mode 100644 index 0000000000000000000000000000000000000000..238a552363a874995d0c4381a6c1ccff4abd452d Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004071.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004081.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004081.png new file mode 100644 index 0000000000000000000000000000000000000000..3a60c875fe9eb5b37ccf477db8218b9a34808c94 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004081.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004091.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004091.png new file mode 100644 index 0000000000000000000000000000000000000000..7280f7077d86e6cca524fa943df288ea765db5b6 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0384_11_05/blur_gamma/004091.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003011.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003011.png new file mode 100644 index 0000000000000000000000000000000000000000..7afd9a3fd9d3a3957bd1ab33b298c36ef6a46ad0 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003011.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003021.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003021.png new file mode 100644 index 0000000000000000000000000000000000000000..6d8575a3413d3a811ac3594977382794e94b595b Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003021.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003031.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003031.png new file mode 100644 index 0000000000000000000000000000000000000000..ecab1ec11f085aa49088bb0f865bfb46646b6c8b Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003031.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003041.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003041.png new file mode 100644 index 0000000000000000000000000000000000000000..51f9a7232261a2b7ea17b2893d25fa6936602841 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003041.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003051.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003051.png new file mode 100644 index 0000000000000000000000000000000000000000..109b9118e442b706cab5f287af53bf7c51d1aa70 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003051.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003061.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003061.png new file mode 100644 index 0000000000000000000000000000000000000000..d631220a0aa79ad481585a5d8e759c6e2897f7b8 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003061.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003071.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003071.png new file mode 100644 index 0000000000000000000000000000000000000000..4f20008bd1aeb74a1c2e38aa500115f229d0f9f7 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003071.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003081.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003081.png new file mode 100644 index 0000000000000000000000000000000000000000..93fb4e3a36a7412b0c22620f3853d5cdae767ad7 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003081.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003091.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003091.png new file mode 100644 index 0000000000000000000000000000000000000000..6e018841282c63b3d2c5bee45d4c10fcfb099b99 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003091.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003101.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003101.png new file mode 100644 index 0000000000000000000000000000000000000000..a4483074c70290d0effdb08ed0a8b4fb9d63e696 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0385_11_01/blur_gamma/003101.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000001.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000001.png new file mode 100644 index 0000000000000000000000000000000000000000..51b4abfb9501c5d2e60a841b11f00dcdff4d1eb1 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000001.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dfcd8f1b5507ed9951031ada43a2c0bfbdf9276932c3dc5b97d70dcb5560e2b3 +size 1213281 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000011.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000011.png new file mode 100644 index 0000000000000000000000000000000000000000..55bf22865f029b53c3395a8ca5ccb3ab158f75b6 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000011.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7fad8a6ea7768e32aadbcb68238d51f71570d719647668fc3838ae6070989d07 +size 1269536 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000021.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000021.png new file mode 100644 index 0000000000000000000000000000000000000000..5dd7e0772c0e553002266dfd19a9df651d21d72a --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000021.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d3626fe1357d1ff1d001ddc533663ab88f4c9229db5604ae186f473b66aa6462 +size 1313067 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000031.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000031.png new file mode 100644 index 0000000000000000000000000000000000000000..c9559fb165860b16f9bb8d852721e25b71a054f9 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000031.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ebd52f3f947ab48a412578eebb4fc80cdf9ffe3024c72ac11c607257279753f8 +size 1282599 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000041.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000041.png new file mode 100644 index 0000000000000000000000000000000000000000..a52e6cfef6412033516e0d71e2f63a67d93970be --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000041.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c69b223484b8c8ba23d725ed8f13940e1bbdd54212bb7f8a5ff7a990186f8f14 +size 1256205 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000051.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000051.png new file mode 100644 index 0000000000000000000000000000000000000000..966120d4a72845a844c27bc8ebaff1521d92e797 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000051.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c77d86b8a251498853988533387c6b8f28952c4edb5435e7b5f3a6f9f89f7b0b +size 1304351 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000061.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000061.png new file mode 100644 index 0000000000000000000000000000000000000000..16125085b2af1b921d98edc89cd8f6e741459045 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000061.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:54e11f3bf5f037f767ecec1db1976c1627fb6c8eccec47b5cd0ef77bbac88909 +size 1345829 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000071.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000071.png new file mode 100644 index 0000000000000000000000000000000000000000..9018921c4287517b13100c7ab5b9e41b563294c3 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000071.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2ba5d6efa8db436e49dfc4dd38e483a9ead5c26e811a206d7457d200341302c0 +size 1301126 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000081.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000081.png new file mode 100644 index 0000000000000000000000000000000000000000..ca610461b7f5b942ea8903d86f849a00a2fb00e1 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000081.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d9bb7c0f2cf20771794b7dd0484b36553d3d690dac344095e98cbda23e46991b +size 1383643 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000091.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000091.png new file mode 100644 index 0000000000000000000000000000000000000000..b6e613ff46705b7831c1df173115f1a63a35bc82 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0396_11_00/blur_gamma/000091.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:45a93da155ad648a23b79eccdb2a568c6ea7672ea05532ff6f45ab2b268fccf0 +size 1282295 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000101.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000101.png new file mode 100644 index 0000000000000000000000000000000000000000..f85db38ea541fd7a2c9f6ef986e3355d3c74a0ce Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000101.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000111.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000111.png new file mode 100644 index 0000000000000000000000000000000000000000..656702eb4e6e7e0bdd5df6b18f77382dbff03192 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000111.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000121.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000121.png new file mode 100644 index 0000000000000000000000000000000000000000..e4426da8f1ca9aa1b411e3609604f126046b2e99 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000121.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000131.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000131.png new file mode 100644 index 0000000000000000000000000000000000000000..5b048d6547fcf7244efb6ef7e1824762d8bbd2fa Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000131.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000141.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000141.png new file mode 100644 index 0000000000000000000000000000000000000000..839e0672fb3572c47353273b02a26f82b86a298c Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000141.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000151.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000151.png new file mode 100644 index 0000000000000000000000000000000000000000..8b1a791faaa59b5b0bd17f5eeec084752831b83a Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000151.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000161.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000161.png new file mode 100644 index 0000000000000000000000000000000000000000..a05d33fb136c269d1156b236e31da2f3c680192a Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000161.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000171.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000171.png new file mode 100644 index 0000000000000000000000000000000000000000..7a62c457f4e7f7a7a7a8b4cfca9124c087767022 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000171.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000181.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000181.png new file mode 100644 index 0000000000000000000000000000000000000000..fc122ce2a5401c730ebd26be69f2c0c1b11eaa49 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000181.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000191.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000191.png new file mode 100644 index 0000000000000000000000000000000000000000..ac12330b1878fb28d6dfee0734b6c4bbfd97ad40 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000191.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000201.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000201.png new file mode 100644 index 0000000000000000000000000000000000000000..b4554c22481dbf41ea45773bd8d70a049e955460 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000201.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000211.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000211.png new file mode 100644 index 0000000000000000000000000000000000000000..750ee43a3dcabc9fa35b9f96ed0b5a6a4b0667b2 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000211.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000221.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000221.png new file mode 100644 index 0000000000000000000000000000000000000000..edff245cf05f48702b00cb52c25cea5c77e717a3 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000221.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000231.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000231.png new file mode 100644 index 0000000000000000000000000000000000000000..c4ac537bd12d4ff535b6836dee1a246621c8c69c Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0410_11_00/blur_gamma/000231.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000007.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000007.png new file mode 100644 index 0000000000000000000000000000000000000000..7aba5c21a00467834ff8f72c4ef0044acc4e311f Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000007.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000017.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000017.png new file mode 100644 index 0000000000000000000000000000000000000000..2b6f13ac2e599cebdbc9abbbc4f9cb537ad68694 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000017.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000027.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000027.png new file mode 100644 index 0000000000000000000000000000000000000000..951a3c264747a38cd2cdf170934920171e818931 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000027.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000037.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000037.png new file mode 100644 index 0000000000000000000000000000000000000000..e1ddcad09e1ffa431d169997b329362b84f50518 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000037.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000047.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000047.png new file mode 100644 index 0000000000000000000000000000000000000000..af17b2d08e495572382cac054425dd5a231efb56 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000047.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000057.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000057.png new file mode 100644 index 0000000000000000000000000000000000000000..9351af6da0c24afb526e54022156abf63f353ed1 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000057.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000067.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000067.png new file mode 100644 index 0000000000000000000000000000000000000000..a11249041cc658cc2919f8e4e81882c5be00a888 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000067.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f9a4df82df1a6388b8b475619b1fb73498f6505aaa9307b0ae198c4184745b3d +size 1045206 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000077.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000077.png new file mode 100644 index 0000000000000000000000000000000000000000..d855293890d5665b9143fe8d89d3004158ecc298 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000077.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000087.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000087.png new file mode 100644 index 0000000000000000000000000000000000000000..dbe6e56499b17fd948cc6378fa2d13b8c2f8d6a4 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000087.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000097.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000097.png new file mode 100644 index 0000000000000000000000000000000000000000..4ac0db1890bb09793011dee9cf382bee6805469a Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0854_11_00/blur_gamma/000097.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000007.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000007.png new file mode 100644 index 0000000000000000000000000000000000000000..4098293ad71380be2c8f26ee37e213a207b0cf32 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000007.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000017.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000017.png new file mode 100644 index 0000000000000000000000000000000000000000..d2078ff94ad823605dfb414d9309995b4665ac3e Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000017.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000027.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000027.png new file mode 100644 index 0000000000000000000000000000000000000000..a92a1861267f42c054a227099511ef2121cf20d1 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000027.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000037.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000037.png new file mode 100644 index 0000000000000000000000000000000000000000..9aa42ed7e48e4477af5b13981d27c7d4a83f8db8 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000037.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000047.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000047.png new file mode 100644 index 0000000000000000000000000000000000000000..89b2c98c4e5de9c58913917bd741566c8af69d3c --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000047.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9bab656d4e57cb0c6c6cfc4288536ee3e027f7b6c2ef6199528c9801b9617289 +size 1095582 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000057.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000057.png new file mode 100644 index 0000000000000000000000000000000000000000..3d211ee6ece22daa81b04bb1a308a038dc5b37ba Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000057.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000067.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000067.png new file mode 100644 index 0000000000000000000000000000000000000000..dd16d899ee8088d8cd18753f1b6d1ffd129ec331 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000067.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000077.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000077.png new file mode 100644 index 0000000000000000000000000000000000000000..f9a6c348f1e1de3bd9604a7d7aba178836df23aa --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0862_11_00/blur_gamma/000077.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f0e8c83f729426d31a7a99a13a634760fa28e8a40eec86494f5857ae19fd0309 +size 1039440 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000010.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000010.png new file mode 100644 index 0000000000000000000000000000000000000000..5d1625ec8ea9bc008eb85fa0eb31b94fe51356a6 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000010.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b499b14518f3019d54622cf7657c326a153a8a04d07fa062702356a599c7793a +size 1046592 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000020.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000020.png new file mode 100644 index 0000000000000000000000000000000000000000..6610ab0efdc1e3aee4c85a341cd2b34ba54d5144 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000020.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5a7e74920030b10b38be0b73de29005fff1ee846645749f4945e31ad45dfb148 +size 1022371 diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000030.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000030.png new file mode 100644 index 0000000000000000000000000000000000000000..8ccba9027ee4c5662295898eed7a15fa1b80b1e5 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000030.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000040.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000040.png new file mode 100644 index 0000000000000000000000000000000000000000..919950d87f13391ace92bc599ffe17cf9244a2f9 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000040.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000050.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000050.png new file mode 100644 index 0000000000000000000000000000000000000000..093f74879bd820ddd7cc758e0b7fb2d13636b748 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000050.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000060.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000060.png new file mode 100644 index 0000000000000000000000000000000000000000..8ff77947e54dbaad4f8cd7594efd4d9461bae2c7 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000060.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000070.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000070.png new file mode 100644 index 0000000000000000000000000000000000000000..e388014676072b363be823ac3bb694aa67834b6a Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000070.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000080.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000080.png new file mode 100644 index 0000000000000000000000000000000000000000..475c3f1062414088dee5f77cd71868070b1f52b8 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000080.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000090.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000090.png new file mode 100644 index 0000000000000000000000000000000000000000..34b1b24cc83fd56931f5b7feea7e7dcf52ccbb8b Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000090.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000100.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000100.png new file mode 100644 index 0000000000000000000000000000000000000000..8a0ac2ee9f7e3efa7f750d0345e962225a374ea2 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0868_11_00/blur_gamma/000100.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000010.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000010.png new file mode 100644 index 0000000000000000000000000000000000000000..a141730076fbc26fcee3b2a3d5d62104c0bb6942 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000010.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000020.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000020.png new file mode 100644 index 0000000000000000000000000000000000000000..14eaa2c231727f1e3478538b8182f019a19fdc55 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000020.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000030.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000030.png new file mode 100644 index 0000000000000000000000000000000000000000..54df60d8c8d688b5e1c0526c8d79e277e3596111 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000030.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000040.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000040.png new file mode 100644 index 0000000000000000000000000000000000000000..36d5c16ea3e74b36f488f60a852c7d67cb6a4916 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000040.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000050.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000050.png new file mode 100644 index 0000000000000000000000000000000000000000..2b3f8a148d12c3cf93cdbfa6b97cb04f960fa62b Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000050.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000060.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000060.png new file mode 100644 index 0000000000000000000000000000000000000000..3bd1191723f477abebe8a4607c35d62f06951988 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000060.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000070.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000070.png new file mode 100644 index 0000000000000000000000000000000000000000..0149d9081e576747c63990b321f785d623a4621a Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000070.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000080.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000080.png new file mode 100644 index 0000000000000000000000000000000000000000..49e52df39ea92ce6a52afc79961fa040953659fb Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000080.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000090.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000090.png new file mode 100644 index 0000000000000000000000000000000000000000..c8598ca1f3563d431ebe67e7709471902668fb41 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000090.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000100.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000100.png new file mode 100644 index 0000000000000000000000000000000000000000..2580f600dda199115cdac214ce1da48cc5323632 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0869_11_00/blur_gamma/000100.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000010.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000010.png new file mode 100644 index 0000000000000000000000000000000000000000..b45ea6535268194f4118c350c4104ce3b56d6841 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000010.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000020.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000020.png new file mode 100644 index 0000000000000000000000000000000000000000..a54a603e11e32a82ff3840ed2fe779326aea8613 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000020.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000030.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000030.png new file mode 100644 index 0000000000000000000000000000000000000000..61f1c6eedb6b097c496aaac80c6f8bb51c354dd6 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000030.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000040.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000040.png new file mode 100644 index 0000000000000000000000000000000000000000..00c35b2d8c10faca8553a58b34c88f878adc99d5 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000040.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000050.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000050.png new file mode 100644 index 0000000000000000000000000000000000000000..ef507efa6953e38a9ec795a666bb50f95069ff4d Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000050.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000060.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000060.png new file mode 100644 index 0000000000000000000000000000000000000000..193041770c6a07461d0fb85abb383778f7990bc5 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000060.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000070.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000070.png new file mode 100644 index 0000000000000000000000000000000000000000..5840da98388ee8e11bcb072c8b5e0a983028aec2 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000070.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000080.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000080.png new file mode 100644 index 0000000000000000000000000000000000000000..40b4ec4c22a4341bbada79454ca2cfb98c0ec108 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000080.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000090.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000090.png new file mode 100644 index 0000000000000000000000000000000000000000..e8ed6704418135e7a65f733a59699bf3f0e0bee9 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000090.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000100.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000100.png new file mode 100644 index 0000000000000000000000000000000000000000..18e4f1c8dbcfc0c79cdf0230761e5e78aa01b539 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0871_11_00/blur_gamma/000100.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000210.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000210.png new file mode 100644 index 0000000000000000000000000000000000000000..3fab5eb19ba7ddb669dfc37036650621f164eeb4 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000210.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000220.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000220.png new file mode 100644 index 0000000000000000000000000000000000000000..d5f75ef769a0139e5f9d991c87b4abb9bc1724c7 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000220.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000230.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000230.png new file mode 100644 index 0000000000000000000000000000000000000000..1aab0f46739aad03c1a07089891836e5785258a9 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000230.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000240.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000240.png new file mode 100644 index 0000000000000000000000000000000000000000..87357d2a530bfdb98d578420631a58d706c7bdb2 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000240.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000250.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000250.png new file mode 100644 index 0000000000000000000000000000000000000000..f9779eeb898b1fd505be07d224470709c916397d Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000250.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000260.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000260.png new file mode 100644 index 0000000000000000000000000000000000000000..91b1e324e46271a12aa8d1632d7ba734ede9ef49 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000260.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000270.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000270.png new file mode 100644 index 0000000000000000000000000000000000000000..67a20fee61c0351124b8f075413b67fab9503363 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000270.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000280.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000280.png new file mode 100644 index 0000000000000000000000000000000000000000..89152b6d40bad594948a77180f604e840e8e9e77 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000280.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000290.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000290.png new file mode 100644 index 0000000000000000000000000000000000000000..4319977f192dfc796decbe211f0c641b4c95880d Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000290.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000300.png b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000300.png new file mode 100644 index 0000000000000000000000000000000000000000..c830eccf9b82130012b0b8c5e72b68583ffa72bd Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/result/GOPR0881_11_01/blur_gamma/000300.png differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/test_loss.pdf b/backup/deblur/experiment/RAFTNET_L1_R6_test/test_loss.pdf new file mode 100644 index 0000000000000000000000000000000000000000..77acc55241a542bf1091358a620d98094984b9b2 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/test_loss.pdf differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/test_metric.pdf b/backup/deblur/experiment/RAFTNET_L1_R6_test/test_metric.pdf new file mode 100644 index 0000000000000000000000000000000000000000..edd4629b9a6af74cb2b68a6935cd352ad1040b94 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/test_metric.pdf differ diff --git a/backup/deblur/experiment/RAFTNET_L1_R6_test/train_loss.pdf b/backup/deblur/experiment/RAFTNET_L1_R6_test/train_loss.pdf new file mode 100644 index 0000000000000000000000000000000000000000..87e1e7b35a9b2094068f10e433d17641078c6520 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_L1_R6_test/train_loss.pdf differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/args.pt b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/args.pt new file mode 100644 index 0000000000000000000000000000000000000000..f511538cb7f509dbebf1cd58ca6128d2a526dee9 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/args.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:04cbaceb052e2a3e27665b1f7986694cb682af1c430a00b7a4f08d1efc6ac828 +size 1903 diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/args.txt b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/args.txt new file mode 100644 index 0000000000000000000000000000000000000000..479517126e35f3bf9ab9978eb8435d44d117e2f1 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/args.txt @@ -0,0 +1,134 @@ +execution at 2020-11-09_23-59-04 +seed: 1604937544 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 2 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNets +pretrained: +n_scales: 5 +detach: False +gaussian_pyramid: True +n_resblocks: 10 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 8 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 2.0 +loss: 1*MSE +metric: PSNR,SSIM +decay_gamma: 0.6 +save_dir: ../experiment/RAFTNET_MSE_R5_rtx +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-10_00-03-10 +seed: 1604937790 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 2 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 1 +model: RaftNets +pretrained: +n_scales: 5 +detach: False +gaussian_pyramid: True +n_resblocks: 10 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 8 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +clip: 2.0 +loss: 1*MSE +metric: PSNR,SSIM +decay_gamma: 0.6 +save_dir: ../experiment/RAFTNET_MSE_R5_rtx +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/loss.pt b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/loss.pt new file mode 100644 index 0000000000000000000000000000000000000000..c0ae07ad2ade475826575ce25d8f025ebb802b50 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/loss.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:84cfa40d9633139092f79852b828f7e0e9923ed4d1ada3bb6243c8554ac0c3f7 +size 1135 diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/models/model-10.pt b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/models/model-10.pt new file mode 100644 index 0000000000000000000000000000000000000000..7f01342bd2a5733fc08d0d442b60b341b2bdf077 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/models/model-10.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d915734bd62797ff4c4db11b2cf3d4bbe42910949f010e6ee2d089c96a586a2f +size 15181994 diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/models/model-20.pt b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/models/model-20.pt new file mode 100644 index 0000000000000000000000000000000000000000..b28a91f975ad1d4eefa0cad1e8c3865d51264636 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/models/model-20.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:11134e74b8df488aec8e96140efbc038840f8e8b612e4a6b237540c67a7d316b +size 15181994 diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/optim/optim-10.pt b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/optim/optim-10.pt new file mode 100644 index 0000000000000000000000000000000000000000..f5adf9a613287215c5025a60157193871073a4d7 --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/optim/optim-10.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e9dc80b902b1d5ef256bd7cfe269293103b00794b7e796ea06b89782a05194f3 +size 30347321 diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/optim/optim-20.pt b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/optim/optim-20.pt new file mode 100644 index 0000000000000000000000000000000000000000..60a11c9e47236ef7be1f0f86e4b04e78fa3e290a --- /dev/null +++ b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/optim/optim-20.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3c9b5a8d13bac979931109a9a1878a1f4f8bffa01b6583e70abee92cdc8adc30 +size 30347321 diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000001.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000001.png new file mode 100644 index 0000000000000000000000000000000000000000..e37f07036123abaa3d75245eb68e4a84977872e5 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000001.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000011.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000011.png new file mode 100644 index 0000000000000000000000000000000000000000..ffee53570650b4135891d6cb9fb62a9c9f789c5c Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000011.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000021.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000021.png new file mode 100644 index 0000000000000000000000000000000000000000..6a3791dc62cb27479b2cfe7febfe8e979b53a524 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000021.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000031.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000031.png new file mode 100644 index 0000000000000000000000000000000000000000..a3201e76c46aa9fc5a0726a2efb94c471fa5554f Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000031.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000041.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000041.png new file mode 100644 index 0000000000000000000000000000000000000000..37bd31ae6ac20c15126fc50029f58e70d2e3a924 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000041.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000051.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000051.png new file mode 100644 index 0000000000000000000000000000000000000000..62bd39ced009e78cc8d6873856bf9369b99255f5 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000051.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000061.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000061.png new file mode 100644 index 0000000000000000000000000000000000000000..e6c31a4df51910005c94c46887bb4686dab75cb7 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000061.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000071.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000071.png new file mode 100644 index 0000000000000000000000000000000000000000..ef350bfc46e5707dcdf228f8c6bca51335271040 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000071.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000081.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000081.png new file mode 100644 index 0000000000000000000000000000000000000000..2094ab6535578605154bb1d8248507308318bb0b Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000081.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000091.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000091.png new file mode 100644 index 0000000000000000000000000000000000000000..37311d76adb0912794c925881cd9598c14b73476 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_00/blur_gamma/000091.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004001.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004001.png new file mode 100644 index 0000000000000000000000000000000000000000..2463eb3e743af19bbefe3d74961850f7ebc0ee72 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004001.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004011.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004011.png new file mode 100644 index 0000000000000000000000000000000000000000..4f225b0cfb457b1b03e45170b8c9652fb14f3be2 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004011.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004021.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004021.png new file mode 100644 index 0000000000000000000000000000000000000000..cb791f5f1bcc948e236394e8a7820b451e97a0f1 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004021.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004031.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004031.png new file mode 100644 index 0000000000000000000000000000000000000000..9831064d2fd2efe10e49484b851dc68150f1b237 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004031.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004041.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004041.png new file mode 100644 index 0000000000000000000000000000000000000000..d089eb208ff6edd670e5435d0cd2db0e5025bc0a Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004041.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004051.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004051.png new file mode 100644 index 0000000000000000000000000000000000000000..cebc3bae387ec1a3fe8b7172e6220b1703433b4e Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004051.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004061.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004061.png new file mode 100644 index 0000000000000000000000000000000000000000..b54021253929dfe490073ea752ff3b51b442ab1d Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004061.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004071.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004071.png new file mode 100644 index 0000000000000000000000000000000000000000..3ecb12638fbdbf31519797467978ca5d6a9c66b4 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004071.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004081.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004081.png new file mode 100644 index 0000000000000000000000000000000000000000..5cecc6a90e8411ccddff94b667758876f4f82c72 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004081.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004091.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004091.png new file mode 100644 index 0000000000000000000000000000000000000000..f97d7bb1ab28351154784710eb726386e143aca5 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0384_11_05/blur_gamma/004091.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003011.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003011.png new file mode 100644 index 0000000000000000000000000000000000000000..3c23b5396a3853689a5fa7b4031954a221f1eac9 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003011.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003021.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003021.png new file mode 100644 index 0000000000000000000000000000000000000000..f9ebcd1bc4518ebf4256b436a9eda56d559d6328 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003021.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003031.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003031.png new file mode 100644 index 0000000000000000000000000000000000000000..413269b6d38787d034f562a2c62f1c5503e3e16d Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003031.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003041.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003041.png new file mode 100644 index 0000000000000000000000000000000000000000..64cb1ad7440a31338952dc333c23b5ab34c397c1 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003041.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003051.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003051.png new file mode 100644 index 0000000000000000000000000000000000000000..5995e864db3084e9efee466b4abf61251b4c8996 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003051.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003061.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003061.png new file mode 100644 index 0000000000000000000000000000000000000000..c7df3698eef9d883f8768bb24a7906f97bc0213b Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003061.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003071.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003071.png new file mode 100644 index 0000000000000000000000000000000000000000..03d221b3319e42649fe58077c5ef436ef17b9d54 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003071.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003081.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003081.png new file mode 100644 index 0000000000000000000000000000000000000000..e807d6a4bf1c84160289833f2a99d5363736b20f Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003081.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003091.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003091.png new file mode 100644 index 0000000000000000000000000000000000000000..6c599cee1d1027da43020496cfdc8613a2ae6e91 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003091.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003101.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003101.png new file mode 100644 index 0000000000000000000000000000000000000000..a7b20730baf8ceb9a0c92bac6bc22fea9665d59b Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0385_11_01/blur_gamma/003101.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000001.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000001.png new file mode 100644 index 0000000000000000000000000000000000000000..2ce86f3585f31e88a3546f557b7d7f518f89a05a Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000001.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000011.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000011.png new file mode 100644 index 0000000000000000000000000000000000000000..f1f1668007ce4b60d6f55de9f3e457f45ce300e9 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000011.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000021.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000021.png new file mode 100644 index 0000000000000000000000000000000000000000..430d0f295c59a5075f6ba013f7b0c78f43ef5d82 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000021.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000031.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000031.png new file mode 100644 index 0000000000000000000000000000000000000000..cb4b9a2c530d5e6deb1da49039ea49e4e017226c Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000031.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000041.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000041.png new file mode 100644 index 0000000000000000000000000000000000000000..ef00b818b0e23cbb933223b7106943fb825fa233 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000041.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000051.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000051.png new file mode 100644 index 0000000000000000000000000000000000000000..c3d663c2505b9cb11387e03e97cf7701e28c3f16 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000051.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000061.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000061.png new file mode 100644 index 0000000000000000000000000000000000000000..5afe3e9b7a8ebd3f626b9877b1fcaee505f43d4f Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000061.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000071.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000071.png new file mode 100644 index 0000000000000000000000000000000000000000..e98523e270a7f7bec6fe968fac2c035edc3fa59e Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000071.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000081.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000081.png new file mode 100644 index 0000000000000000000000000000000000000000..f0afcd96adaf0b80c5c5c3b24d5df970351c8876 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000081.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000091.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000091.png new file mode 100644 index 0000000000000000000000000000000000000000..9f79a99cbacf4afcb9d25aff8f38a1bbb629c582 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0396_11_00/blur_gamma/000091.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000101.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000101.png new file mode 100644 index 0000000000000000000000000000000000000000..0cf6b8a587c43609154f3f53947569d615a39df0 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000101.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000111.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000111.png new file mode 100644 index 0000000000000000000000000000000000000000..cc01c7053df80fc7233116710c36181a9a694f19 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000111.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000121.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000121.png new file mode 100644 index 0000000000000000000000000000000000000000..860f4f0678be90e81e50a49a8bc2916dcaa15d82 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000121.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000131.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000131.png new file mode 100644 index 0000000000000000000000000000000000000000..415e816f6867fff6620229c3705b3905e81e3dbf Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000131.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000141.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000141.png new file mode 100644 index 0000000000000000000000000000000000000000..ec39218f7935d497c833a9dc22067bc4cd10edf3 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000141.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000151.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000151.png new file mode 100644 index 0000000000000000000000000000000000000000..865ba4c0abf7f306d48558aeb6cef728750c0f1b Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000151.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000161.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000161.png new file mode 100644 index 0000000000000000000000000000000000000000..43c20b571983433224fed499637d8f0cfe044491 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000161.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000171.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000171.png new file mode 100644 index 0000000000000000000000000000000000000000..007576ac93b07528a52b1d1be9a2fe799cf551d0 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000171.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000181.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000181.png new file mode 100644 index 0000000000000000000000000000000000000000..ac12eadac9642c6635eaa37d2213818aef2521c9 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000181.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000191.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000191.png new file mode 100644 index 0000000000000000000000000000000000000000..4f2ce53a5101514ebaf17870180e9aab595b8c3d Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000191.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000201.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000201.png new file mode 100644 index 0000000000000000000000000000000000000000..48962c3d50f1d7bdb70cb6756453bd1caf575b09 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000201.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000211.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000211.png new file mode 100644 index 0000000000000000000000000000000000000000..a83f8784858ae295f7e2fe90034e805af340eed2 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000211.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000221.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000221.png new file mode 100644 index 0000000000000000000000000000000000000000..7589820f7fe40fe956402cb06a125fcd72ffd17c Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000221.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000231.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000231.png new file mode 100644 index 0000000000000000000000000000000000000000..4e7d2223bfdc6245034dc0df67859fcbad174431 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0410_11_00/blur_gamma/000231.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000007.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000007.png new file mode 100644 index 0000000000000000000000000000000000000000..a263adcd774f495457e962d4881fd391b682513a Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000007.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000017.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000017.png new file mode 100644 index 0000000000000000000000000000000000000000..5b5f90875d58f1a14f18cdb42bae09b9f67aea48 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000017.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000027.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000027.png new file mode 100644 index 0000000000000000000000000000000000000000..ad902f83dd95997c1a9772dc6088a7a499e20268 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000027.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000037.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000037.png new file mode 100644 index 0000000000000000000000000000000000000000..70dfd3a6358d507373fa9bb860f7a45af34e137f Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000037.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000047.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000047.png new file mode 100644 index 0000000000000000000000000000000000000000..3a66078aa5e5eb981524446c14e45c175f1bc773 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000047.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000057.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000057.png new file mode 100644 index 0000000000000000000000000000000000000000..a5bc12091023d43a8324e595f994b6ed61ef355d Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000057.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000067.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000067.png new file mode 100644 index 0000000000000000000000000000000000000000..5c6c7da505f193f06522d22c5a04b5e3e0c459ac Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000067.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000077.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000077.png new file mode 100644 index 0000000000000000000000000000000000000000..954633f1a52cc4fad09006414e05976be9f67ff3 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000077.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000087.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000087.png new file mode 100644 index 0000000000000000000000000000000000000000..93d7486d87867996e7e15d83bd87cf9903c1188f Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000087.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000097.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000097.png new file mode 100644 index 0000000000000000000000000000000000000000..3b0b7b1b6ca8a4297fe47a27b9310a0f4547ac2b Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0854_11_00/blur_gamma/000097.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000007.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000007.png new file mode 100644 index 0000000000000000000000000000000000000000..8f22a02e678488509d870b3f21fd4a5e05852401 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000007.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000017.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000017.png new file mode 100644 index 0000000000000000000000000000000000000000..3d6e379ed91c5acbf7703e9141131b1a29e08e23 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000017.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000027.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000027.png new file mode 100644 index 0000000000000000000000000000000000000000..9cde27256e1637015b5714af39ef2526e89b8362 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000027.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000037.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000037.png new file mode 100644 index 0000000000000000000000000000000000000000..72d3c58cd4fd459c9dc13c03bac0de9d0412ebcc Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000037.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000047.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000047.png new file mode 100644 index 0000000000000000000000000000000000000000..4a9ae1e2f3647a7bbaba364990ce0fb92dd392c7 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000047.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000057.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000057.png new file mode 100644 index 0000000000000000000000000000000000000000..fa500897d6e97da9b8256f4a45c1643cc94aaf73 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000057.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000067.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000067.png new file mode 100644 index 0000000000000000000000000000000000000000..72054d638ec4c261a2b69b37940fe40ad626909a Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000067.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000077.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000077.png new file mode 100644 index 0000000000000000000000000000000000000000..c4ed37ae6ce7cf07f15248ffaf636dc93f5753e9 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0862_11_00/blur_gamma/000077.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000010.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000010.png new file mode 100644 index 0000000000000000000000000000000000000000..2f8adc53f240e4ec60af68200650d3ae90448d87 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000010.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000020.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000020.png new file mode 100644 index 0000000000000000000000000000000000000000..801c7623cb1f96056ebeab82081ed42d549d9ba0 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000020.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000030.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000030.png new file mode 100644 index 0000000000000000000000000000000000000000..9bafbe5554790b112f41394edd9935cae05de740 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000030.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000040.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000040.png new file mode 100644 index 0000000000000000000000000000000000000000..cc7cced3e2ba910449face94be7d3e37f98dc43c Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000040.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000050.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000050.png new file mode 100644 index 0000000000000000000000000000000000000000..9fe6c7f7da30de525f03469986be7b2f56471de9 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000050.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000060.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000060.png new file mode 100644 index 0000000000000000000000000000000000000000..a297c014310f23b7d1a50852cd22b982dd0a2a9e Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000060.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000070.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000070.png new file mode 100644 index 0000000000000000000000000000000000000000..80506c3326e984639dc9ef1de9630b0ca20c4928 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000070.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000080.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000080.png new file mode 100644 index 0000000000000000000000000000000000000000..fa061f8a938ff3c0480898dcf1c36a0661fffe76 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000080.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000090.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000090.png new file mode 100644 index 0000000000000000000000000000000000000000..0c2f0feebc48c4d5b3b35b0a83042adb4c1be304 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000090.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000100.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000100.png new file mode 100644 index 0000000000000000000000000000000000000000..c9424e0d755e2422af97d7ec94b040348796c5a1 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0868_11_00/blur_gamma/000100.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000010.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000010.png new file mode 100644 index 0000000000000000000000000000000000000000..dba91ba814d1b0c98dd5e3cd109ef076091ab0ed Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000010.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000020.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000020.png new file mode 100644 index 0000000000000000000000000000000000000000..01a97fdafd3ded387bfa7bf67b71bbb313e52202 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000020.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000030.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000030.png new file mode 100644 index 0000000000000000000000000000000000000000..ad66b0efab15e74c6712ce36691d0d4fbe7e6796 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000030.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000040.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000040.png new file mode 100644 index 0000000000000000000000000000000000000000..baa0df263b3972b2d404df6d67a02ced0b330095 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000040.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000050.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000050.png new file mode 100644 index 0000000000000000000000000000000000000000..17203858d86eb4a6ca1e6da824ee0ef39be14cba Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000050.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000060.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000060.png new file mode 100644 index 0000000000000000000000000000000000000000..18233fb930039b6dfd1db4ad76acf4d3164c72c2 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000060.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000070.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000070.png new file mode 100644 index 0000000000000000000000000000000000000000..0614ed657747b1c9b68041e7523b1cc1091744d7 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000070.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000080.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000080.png new file mode 100644 index 0000000000000000000000000000000000000000..678ee83f26748ebd7f6e259331ae44e3786fb03e Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000080.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000090.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000090.png new file mode 100644 index 0000000000000000000000000000000000000000..b3f6286d9a6d5d5efa25feed592ccd03ab226d71 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000090.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000100.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000100.png new file mode 100644 index 0000000000000000000000000000000000000000..4c197e233c235c10703478ca65100c1b36fc73ef Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0869_11_00/blur_gamma/000100.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000010.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000010.png new file mode 100644 index 0000000000000000000000000000000000000000..8b9ddecb6e697ddb36424cd51a463179771ccd36 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000010.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000020.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000020.png new file mode 100644 index 0000000000000000000000000000000000000000..6a639f91e6fd7655a8a8b3d2a6d2b93e2e5643ff Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000020.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000030.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000030.png new file mode 100644 index 0000000000000000000000000000000000000000..226aa29b4c39169da32fbf921a9d4125ac9d9703 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000030.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000040.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000040.png new file mode 100644 index 0000000000000000000000000000000000000000..0d03f68c3768c0003b59959248fc6e9f5a63be66 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000040.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000050.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000050.png new file mode 100644 index 0000000000000000000000000000000000000000..fb9da88184efabba8e7284019b29bac3a90521a8 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000050.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000060.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000060.png new file mode 100644 index 0000000000000000000000000000000000000000..301091c8d84895a35008b8ac31a0a3697af35b69 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000060.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000070.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000070.png new file mode 100644 index 0000000000000000000000000000000000000000..05c62fd3e6eeb925c461b9a8092aee5f5afe5d27 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000070.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000080.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000080.png new file mode 100644 index 0000000000000000000000000000000000000000..24ef75c30e4179b0f9195c6d7230dcfdb35f0e3d Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000080.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000090.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000090.png new file mode 100644 index 0000000000000000000000000000000000000000..2888197956c9a96cf202ccebd198134dfb25f90b Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000090.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000100.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000100.png new file mode 100644 index 0000000000000000000000000000000000000000..f53069148489c3c19c35cc6de036fa61af3acc6f Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0871_11_00/blur_gamma/000100.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000210.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000210.png new file mode 100644 index 0000000000000000000000000000000000000000..feacae184581e94fd7c95643c760a93d13bdfa67 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000210.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000220.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000220.png new file mode 100644 index 0000000000000000000000000000000000000000..428d1aed290e67dda241d48a6e3aeed43143c74b Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000220.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000230.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000230.png new file mode 100644 index 0000000000000000000000000000000000000000..f5827884d645eca21ac6bec9870a3ebea80cd258 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000230.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000240.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000240.png new file mode 100644 index 0000000000000000000000000000000000000000..0d12a4ea5454718ffa83a79e144775901737c425 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000240.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000250.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000250.png new file mode 100644 index 0000000000000000000000000000000000000000..6f02bb30177e0f799804a43f121e9a1a3643bc95 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000250.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000260.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000260.png new file mode 100644 index 0000000000000000000000000000000000000000..435a76d24dc097e8d3d1372bd33cf18f5497a952 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000260.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000270.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000270.png new file mode 100644 index 0000000000000000000000000000000000000000..cc1dce8465c9dfb035da1cc9e6dad2d4247a5a05 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000270.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000280.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000280.png new file mode 100644 index 0000000000000000000000000000000000000000..80ba01c3396ca2e02a84eab9fdd6ce667c7b56c6 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000280.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000290.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000290.png new file mode 100644 index 0000000000000000000000000000000000000000..07b761294fc530a37bc00b0cdc0e00c5474f434e Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000290.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000300.png b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000300.png new file mode 100644 index 0000000000000000000000000000000000000000..eea04c68a3d94d4aa2aa417c124bdf01705e0686 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/result/GOPR0881_11_01/blur_gamma/000300.png differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/test_loss.pdf b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/test_loss.pdf new file mode 100644 index 0000000000000000000000000000000000000000..adab9b6603a7e51a99996bdb7b5ac53cef98a5d3 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/test_loss.pdf differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/test_metric.pdf b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/test_metric.pdf new file mode 100644 index 0000000000000000000000000000000000000000..5dae65cfd3a87ae488522867f65ba42f0c5b9421 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/test_metric.pdf differ diff --git a/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/train_loss.pdf b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/train_loss.pdf new file mode 100644 index 0000000000000000000000000000000000000000..7d43e3aa8376bd947b25c1d96633561c1939b8f3 Binary files /dev/null and b/backup/deblur/experiment/RAFTNET_MSE_R5_rtx/train_loss.pdf differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/.ipynb_checkpoints/train_loss-checkpoint.pdf b/backup/deblur/experiment/RecLamRes_MSE/.ipynb_checkpoints/train_loss-checkpoint.pdf new file mode 100644 index 0000000000000000000000000000000000000000..2c1f3889185a32c37bd914eb9800f868d30659ac Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/.ipynb_checkpoints/train_loss-checkpoint.pdf differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/args.pt b/backup/deblur/experiment/RecLamRes_MSE/args.pt new file mode 100644 index 0000000000000000000000000000000000000000..49aa788e8f3fb8e1ae055b1f5fc3e935fa9ec4b6 --- /dev/null +++ b/backup/deblur/experiment/RecLamRes_MSE/args.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5b5c4a6e8ce0af53b06bff0f70c5ddefc6128a0855a2db970273871cc55515fb +size 1839 diff --git a/backup/deblur/experiment/RecLamRes_MSE/args.txt b/backup/deblur/experiment/RecLamRes_MSE/args.txt new file mode 100644 index 0000000000000000000000000000000000000000..b42557ace1714c0cf60eae692816f9404b35b449 --- /dev/null +++ b/backup/deblur/experiment/RecLamRes_MSE/args.txt @@ -0,0 +1,193 @@ +execution at 2020-11-05_16-16-51 +seed: 1604564211 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 2 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 255 +model: RecLamResNet +pretrained: +n_scales: 5 +gaussian_pyramid: True +n_resblocks: 19 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 16 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +loss: 1*MSE +metric: PSNR,SSIM +save_dir: ../experiment/RecLamRes_MSE +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-05_16-19-01 +seed: 1604564341 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 2 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 255 +model: RecLamResNet +pretrained: +n_scales: 5 +gaussian_pyramid: True +n_resblocks: 19 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 16 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +loss: 1*MSE +metric: PSNR,SSIM +save_dir: ../experiment/RecLamRes_MSE +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-05_22-52-44 +seed: 1604587964 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 2 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 255 +model: RecLamResNet +pretrained: +n_scales: 5 +detach: False +gaussian_pyramid: True +n_resblocks: 19 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 16 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +loss: 1*MSE +metric: PSNR,SSIM +save_dir: ../experiment/RecLamRes_MSE +start_epoch: 11 +end_epoch: 1000 +load_epoch: 10 +save_every: 10 +save_results: part +stay: False +template: + diff --git a/backup/deblur/experiment/RecLamRes_MSE/loss.pt b/backup/deblur/experiment/RecLamRes_MSE/loss.pt new file mode 100644 index 0000000000000000000000000000000000000000..388a3b04f3d1e50410bdab8cfffdb7e13be1c315 --- /dev/null +++ b/backup/deblur/experiment/RecLamRes_MSE/loss.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a87bb8541d0c7109cac28528528151b960e53b1ed5baa62ee8d03a69a135aaf4 +size 1391 diff --git a/backup/deblur/experiment/RecLamRes_MSE/models/model-10.pt b/backup/deblur/experiment/RecLamRes_MSE/models/model-10.pt new file mode 100644 index 0000000000000000000000000000000000000000..4e63a3f134e57e3ec64849346b1ffa42be00f07e --- /dev/null +++ b/backup/deblur/experiment/RecLamRes_MSE/models/model-10.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:34f8f71c8dc212fea712335d29692c8e422858b5bd2de2d9c9ad1303e9f0b037 +size 15350843 diff --git a/backup/deblur/experiment/RecLamRes_MSE/models/model-20.pt b/backup/deblur/experiment/RecLamRes_MSE/models/model-20.pt new file mode 100644 index 0000000000000000000000000000000000000000..b551fe18b1513db88d619efafac9d92b6bbb6c26 --- /dev/null +++ b/backup/deblur/experiment/RecLamRes_MSE/models/model-20.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8600313d048cbe5990ef8128bc7b211b991e11b541beda4eb0c0bffb0614ddf3 +size 15350843 diff --git a/backup/deblur/experiment/RecLamRes_MSE/models/model-30.pt b/backup/deblur/experiment/RecLamRes_MSE/models/model-30.pt new file mode 100644 index 0000000000000000000000000000000000000000..5b974d7fbfc6a725a1dcbb5b1b145c3dd1e6dde0 --- /dev/null +++ b/backup/deblur/experiment/RecLamRes_MSE/models/model-30.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:41125cc3cfd0900296550842a8141250bdf034711589b504653ce14ad3b6c96e +size 15350843 diff --git a/backup/deblur/experiment/RecLamRes_MSE/optim/optim-10.pt b/backup/deblur/experiment/RecLamRes_MSE/optim/optim-10.pt new file mode 100644 index 0000000000000000000000000000000000000000..7ab67400d86ea7decc1bc56c9e918892e69de3f8 --- /dev/null +++ b/backup/deblur/experiment/RecLamRes_MSE/optim/optim-10.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0d6f89350790f3eb259630bae7af1b4b147e3df9b234b1baf3129dbac36a8ca1 +size 30674863 diff --git a/backup/deblur/experiment/RecLamRes_MSE/optim/optim-20.pt b/backup/deblur/experiment/RecLamRes_MSE/optim/optim-20.pt new file mode 100644 index 0000000000000000000000000000000000000000..674a0cb7cc5adba37cb19cadabc3af23be39cbca --- /dev/null +++ b/backup/deblur/experiment/RecLamRes_MSE/optim/optim-20.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:44c0137f5b6acf7b6fddec6b1a8c40f300e340fd1e227f6363b7c82577b3d96c +size 30674863 diff --git a/backup/deblur/experiment/RecLamRes_MSE/optim/optim-30.pt b/backup/deblur/experiment/RecLamRes_MSE/optim/optim-30.pt new file mode 100644 index 0000000000000000000000000000000000000000..803cd252078a252b348f5a64b5c4fdb8247d0219 --- /dev/null +++ b/backup/deblur/experiment/RecLamRes_MSE/optim/optim-30.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4c148da31b0ece985d74877e15d4245cdb79afe7df9d036647e7f8234c00b31d +size 30674863 diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000001.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000001.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000001.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000011.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000011.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000011.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000021.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000021.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000021.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000031.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000031.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000031.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000041.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000041.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000041.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000051.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000051.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000051.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000061.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000061.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000061.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000071.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000071.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000071.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000081.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000081.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000081.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000091.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000091.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_00/blur_gamma/000091.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004001.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004001.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004001.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004011.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004011.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004011.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004021.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004021.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004021.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004031.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004031.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004031.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004041.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004041.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004041.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004051.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004051.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004051.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004061.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004061.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004061.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004071.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004071.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004071.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004081.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004081.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004081.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004091.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004091.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0384_11_05/blur_gamma/004091.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003011.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003011.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003011.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003021.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003021.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003021.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003031.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003031.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003031.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003041.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003041.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003041.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003051.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003051.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003051.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003061.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003061.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003061.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003071.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003071.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003071.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003081.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003081.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003081.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003091.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003091.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003091.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003101.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003101.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0385_11_01/blur_gamma/003101.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000001.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000001.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000001.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000011.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000011.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000011.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000021.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000021.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000021.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000031.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000031.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000031.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000041.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000041.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000041.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000051.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000051.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000051.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000061.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000061.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000061.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000071.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000071.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000071.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000081.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000081.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000081.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000091.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000091.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0396_11_00/blur_gamma/000091.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000101.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000101.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000101.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000111.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000111.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000111.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000121.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000121.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000121.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000131.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000131.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000131.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000141.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000141.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000141.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000151.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000151.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000151.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000161.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000161.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000161.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000171.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000171.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000171.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000181.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000181.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000181.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000191.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000191.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000191.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000201.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000201.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000201.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000211.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000211.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000211.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000221.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000221.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000221.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000231.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000231.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0410_11_00/blur_gamma/000231.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000007.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000007.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000007.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000017.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000017.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000017.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000027.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000027.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000027.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000037.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000037.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000037.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000047.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000047.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000047.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000057.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000057.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000057.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000067.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000067.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000067.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000077.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000077.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000077.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000087.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000087.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000087.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000097.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000097.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0854_11_00/blur_gamma/000097.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000007.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000007.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000007.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000017.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000017.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000017.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000027.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000027.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000027.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000037.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000037.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000037.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000047.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000047.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000047.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000057.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000057.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000057.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000067.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000067.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000067.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000077.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000077.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0862_11_00/blur_gamma/000077.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000010.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000010.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000010.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000020.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000020.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000020.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000030.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000030.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000030.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000040.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000040.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000040.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000050.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000050.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000050.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000060.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000060.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000060.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000070.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000070.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000070.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000080.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000080.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000080.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000090.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000090.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000090.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000100.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000100.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0868_11_00/blur_gamma/000100.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000010.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000010.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000010.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000020.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000020.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000020.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000030.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000030.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000030.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000040.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000040.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000040.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000050.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000050.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000050.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000060.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000060.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000060.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000070.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000070.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000070.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000080.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000080.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000080.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000090.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000090.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000090.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000100.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000100.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0869_11_00/blur_gamma/000100.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000010.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000010.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000010.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000020.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000020.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000020.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000030.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000030.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000030.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000040.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000040.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000040.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000050.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000050.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000050.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000060.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000060.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000060.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000070.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000070.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000070.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000080.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000080.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000080.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000090.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000090.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000090.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000100.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000100.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0871_11_00/blur_gamma/000100.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000210.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000210.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000210.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000220.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000220.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000220.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000230.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000230.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000230.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000240.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000240.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000240.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000250.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000250.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000250.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000260.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000260.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000260.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000270.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000270.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000270.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000280.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000280.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000280.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000290.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000290.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000290.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000300.png b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000300.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/result/GOPR0881_11_01/blur_gamma/000300.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/test_loss.pdf b/backup/deblur/experiment/RecLamRes_MSE/test_loss.pdf new file mode 100644 index 0000000000000000000000000000000000000000..b06924a2283a573e60d359b7d1f55421b1fdb7d7 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/test_loss.pdf differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/test_metric.pdf b/backup/deblur/experiment/RecLamRes_MSE/test_metric.pdf new file mode 100644 index 0000000000000000000000000000000000000000..e90c206257ce21bbf0923b6887fe67975101f30e Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/test_metric.pdf differ diff --git a/backup/deblur/experiment/RecLamRes_MSE/train_loss.pdf b/backup/deblur/experiment/RecLamRes_MSE/train_loss.pdf new file mode 100644 index 0000000000000000000000000000000000000000..88efc5176f9979c36514be81692035400a7f1a1e Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE/train_loss.pdf differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_Revert/args.pt b/backup/deblur/experiment/RecLamRes_MSE_Revert/args.pt new file mode 100644 index 0000000000000000000000000000000000000000..d3132a011066ff0bfd07d767944235ef2a2ce467 --- /dev/null +++ b/backup/deblur/experiment/RecLamRes_MSE_Revert/args.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:92e91d7178249362187636bdc912520ba75adc96206979f4211dafe1950f8957 +size 1839 diff --git a/backup/deblur/experiment/RecLamRes_MSE_Revert/args.txt b/backup/deblur/experiment/RecLamRes_MSE_Revert/args.txt new file mode 100644 index 0000000000000000000000000000000000000000..44389452a03dae425be41928208f37462dfb2993 --- /dev/null +++ b/backup/deblur/experiment/RecLamRes_MSE_Revert/args.txt @@ -0,0 +1,65 @@ +execution at 2020-11-08_00-31-01 +seed: 1604766661 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 2 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 255 +model: RecLamResNet +pretrained: +n_scales: 5 +detach: False +gaussian_pyramid: True +n_resblocks: 19 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 16 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +loss: 1*MSE +metric: PSNR,SSIM +save_dir: ../experiment/RecLamRes_MSE_Revert +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/args.pt b/backup/deblur/experiment/RecLamRes_MSE_detach/args.pt new file mode 100644 index 0000000000000000000000000000000000000000..99a3d385f19eafca79afff43bd45b0d8db7e4cd0 --- /dev/null +++ b/backup/deblur/experiment/RecLamRes_MSE_detach/args.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1390bfb73c71b4b58d185b01a198f909e6a844481a83fa4f0fbcb98676d2c703 +size 1839 diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/args.txt b/backup/deblur/experiment/RecLamRes_MSE_detach/args.txt new file mode 100644 index 0000000000000000000000000000000000000000..28014db19bfb06b59c140742eaf4c0ee870d6472 --- /dev/null +++ b/backup/deblur/experiment/RecLamRes_MSE_detach/args.txt @@ -0,0 +1,260 @@ +execution at 2020-11-05_20-26-19 +seed: 1604579179 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 2 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8023 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 255 +model: RecLamResNet +pretrained: +n_scales: 5 +detach: True +gaussian_pyramid: True +n_resblocks: 19 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 16 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +loss: 1*MSE +metric: PSNR,SSIM +save_dir: ../experiment/RecLamRes_MSE_detach +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-05_20-33-14 +seed: 1604579594 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 2 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8025 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 255 +model: RecLamResNet +pretrained: +n_scales: 5 +detach: True +gaussian_pyramid: True +n_resblocks: 19 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 16 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +loss: 1*MSE +metric: PSNR,SSIM +save_dir: ../experiment/RecLamRes_MSE_detach +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-05_20-33-53 +seed: 1604579633 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 2 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8025 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 255 +model: RecLamResNet +pretrained: +n_scales: 5 +detach: True +gaussian_pyramid: True +n_resblocks: 19 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 8 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +loss: 1*MSE +metric: PSNR,SSIM +save_dir: ../experiment/RecLamRes_MSE_detach +start_epoch: 1 +end_epoch: 1000 +load_epoch: 0 +save_every: 10 +save_results: part +stay: False +template: + +execution at 2020-11-06_09-00-59 +seed: 1604624459 +num_workers: 7 +device_type: cuda +device_index: 0 +n_GPUs: 2 +distributed: True +launched: True +master_addr: 127.0.0.1 +master_port: 8025 +dist_backend: nccl +init_method: env:// +rank: 0 +world_size: 1 +data_root: /data/ssd/public/czli/deblur +dataset: None +data_train: GOPRO_Large +data_val: None +data_test: GOPRO_Large +blur_key: blur_gamma +rgb_range: 255 +model: RecLamResNet +pretrained: +n_scales: 5 +detach: True +gaussian_pyramid: True +n_resblocks: 19 +n_feats: 64 +kernel_size: 5 +downsample: Gaussian +precision: single +amp: True +init_scale: 1024.0 +patch_size: 256 +batch_size: 8 +split_batch: 1 +augment: True +validate_every: 10 +test_every: 10 +do_train: True +do_validate: False +do_test: True +demo: False +demo_input_dir: +demo_output_dir: +lr: 0.0001 +milestones: [500, 750, 900] +scheduler: step +gamma: 0.5 +optimizer: ADAM +momentum: 0.9 +betas: (0.9, 0.999) +epsilon: 1e-08 +weight_decay: 0 +loss: 1*MSE +metric: PSNR,SSIM +save_dir: ../experiment/RecLamRes_MSE_detach +start_epoch: 21 +end_epoch: 1000 +load_epoch: 20 +save_every: 10 +save_results: part +stay: False +template: + diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/loss.pt b/backup/deblur/experiment/RecLamRes_MSE_detach/loss.pt new file mode 100644 index 0000000000000000000000000000000000000000..a0d582373f48e8109cfc06c0289750402a75700b --- /dev/null +++ b/backup/deblur/experiment/RecLamRes_MSE_detach/loss.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5214554e4293d97ba2784e21cd8e66cce4eee81a01b054f4760732cbb483191e +size 1007 diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/models/model-10.pt b/backup/deblur/experiment/RecLamRes_MSE_detach/models/model-10.pt new file mode 100644 index 0000000000000000000000000000000000000000..432ce08efdc13074c01bb83ac2f2fc084d0f6645 --- /dev/null +++ b/backup/deblur/experiment/RecLamRes_MSE_detach/models/model-10.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dd3968941646c1048b81cec1aac2dbe08e4a5cc63491ef8f539ab1b3a9b8ba4f +size 15350843 diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/models/model-20.pt b/backup/deblur/experiment/RecLamRes_MSE_detach/models/model-20.pt new file mode 100644 index 0000000000000000000000000000000000000000..f8384a9174d78c80e48affe3c3336aebd18f55c2 --- /dev/null +++ b/backup/deblur/experiment/RecLamRes_MSE_detach/models/model-20.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:af39b34063ba2976d530f44ff59f512cc4eee55d954d22499ec39344d746a883 +size 15350843 diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/optim/optim-10.pt b/backup/deblur/experiment/RecLamRes_MSE_detach/optim/optim-10.pt new file mode 100644 index 0000000000000000000000000000000000000000..6058514958ee85cf758a37baf7c7f7127ed37f94 --- /dev/null +++ b/backup/deblur/experiment/RecLamRes_MSE_detach/optim/optim-10.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b7aeb3518f0c1ca1c46e46f894573d235cd4e953d61a5641a2ee7b22ed4c84e1 +size 30674863 diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/optim/optim-20.pt b/backup/deblur/experiment/RecLamRes_MSE_detach/optim/optim-20.pt new file mode 100644 index 0000000000000000000000000000000000000000..8304af2bc04e8e492e07891c784dd2f32e94e267 --- /dev/null +++ b/backup/deblur/experiment/RecLamRes_MSE_detach/optim/optim-20.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d025638b7c31bdfd49c0cec67f0e2a661bea38aab7705134828e1eca01cae3ce +size 30674863 diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000001.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000001.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000001.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000011.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000011.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000011.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000021.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000021.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000021.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000031.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000031.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000031.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000041.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000041.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000041.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000051.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000051.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000051.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000061.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000061.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000061.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000071.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000071.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000071.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000081.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000081.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000081.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000091.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000091.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_00/blur_gamma/000091.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004001.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004001.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004001.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004011.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004011.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004011.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004021.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004021.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004021.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004031.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004031.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004031.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004041.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004041.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004041.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004051.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004051.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004051.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004061.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004061.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004061.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004071.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004071.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004071.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004081.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004081.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004081.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004091.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004091.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0384_11_05/blur_gamma/004091.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003011.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003011.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003011.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003021.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003021.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003021.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003031.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003031.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003031.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003041.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003041.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003041.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003051.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003051.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003051.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003061.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003061.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003061.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003071.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003071.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003071.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003081.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003081.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003081.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003091.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003091.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003091.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003101.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003101.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0385_11_01/blur_gamma/003101.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000001.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000001.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000001.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000011.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000011.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000011.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000021.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000021.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000021.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000031.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000031.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000031.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000041.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000041.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000041.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000051.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000051.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000051.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000061.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000061.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000061.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000071.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000071.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000071.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000081.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000081.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000081.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000091.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000091.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0396_11_00/blur_gamma/000091.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000101.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000101.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000101.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000111.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000111.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000111.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000121.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000121.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000121.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000131.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000131.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000131.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000141.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000141.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000141.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000151.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000151.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000151.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000161.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000161.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000161.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000171.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000171.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000171.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000181.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000181.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000181.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000191.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000191.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000191.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000201.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000201.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000201.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000211.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000211.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000211.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000221.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000221.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000221.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000231.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000231.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0410_11_00/blur_gamma/000231.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000007.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000007.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000007.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000017.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000017.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000017.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000027.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000027.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000027.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000037.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000037.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000037.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000047.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000047.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000047.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000057.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000057.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000057.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000067.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000067.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000067.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000077.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000077.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000077.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000087.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000087.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000087.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000097.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000097.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0854_11_00/blur_gamma/000097.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000007.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000007.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000007.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000017.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000017.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000017.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000027.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000027.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000027.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000037.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000037.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000037.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000047.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000047.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000047.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000057.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000057.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000057.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000067.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000067.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000067.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000077.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000077.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0862_11_00/blur_gamma/000077.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000010.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000010.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000010.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000020.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000020.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000020.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000030.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000030.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000030.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000040.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000040.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000040.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000050.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000050.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000050.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000060.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000060.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000060.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000070.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000070.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000070.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000080.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000080.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000080.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000090.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000090.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000090.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000100.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000100.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0868_11_00/blur_gamma/000100.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000010.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000010.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000010.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000020.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000020.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000020.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000030.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000030.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000030.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000040.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000040.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000040.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000050.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000050.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000050.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000060.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000060.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000060.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000070.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000070.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000070.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000080.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000080.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000080.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000090.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000090.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000090.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000100.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000100.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0869_11_00/blur_gamma/000100.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000010.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000010.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000010.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000020.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000020.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000020.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000030.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000030.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000030.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000040.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000040.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000040.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000050.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000050.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000050.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000060.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000060.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000060.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000070.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000070.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000070.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000080.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000080.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000080.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000090.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000090.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000090.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000100.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000100.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0871_11_00/blur_gamma/000100.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000210.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000210.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000210.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000220.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000220.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000220.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000230.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000230.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000230.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000240.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000240.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000240.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000250.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000250.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000250.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000260.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000260.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000260.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000270.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000270.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000270.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000280.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000280.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000280.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000290.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000290.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000290.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000300.png b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000300.png new file mode 100644 index 0000000000000000000000000000000000000000..e0440e15663d8ff0a976a19aa2c9e0ed51219e79 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/result/GOPR0881_11_01/blur_gamma/000300.png differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/test_loss.pdf b/backup/deblur/experiment/RecLamRes_MSE_detach/test_loss.pdf new file mode 100644 index 0000000000000000000000000000000000000000..efbbfb7bbb25741d50ce89730073ba7ec8c65bfb Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/test_loss.pdf differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/test_metric.pdf b/backup/deblur/experiment/RecLamRes_MSE_detach/test_metric.pdf new file mode 100644 index 0000000000000000000000000000000000000000..09cdd13ee71b8f51d27858c156ef741d2fcec804 Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/test_metric.pdf differ diff --git a/backup/deblur/experiment/RecLamRes_MSE_detach/train_loss.pdf b/backup/deblur/experiment/RecLamRes_MSE_detach/train_loss.pdf new file mode 100644 index 0000000000000000000000000000000000000000..ff212c55091684bc765d72fec719fb17a46de49e Binary files /dev/null and b/backup/deblur/experiment/RecLamRes_MSE_detach/train_loss.pdf differ diff --git a/backup/deblur/src/__pycache__/option.cpython-37.pyc b/backup/deblur/src/__pycache__/option.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..776c0963b1a4e51e34f2583825a16c764cf2280b Binary files /dev/null and b/backup/deblur/src/__pycache__/option.cpython-37.pyc differ diff --git a/backup/deblur/src/__pycache__/template.cpython-37.pyc b/backup/deblur/src/__pycache__/template.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5ab004cf54c21d5e68faf23ce678616ff5549f82 Binary files /dev/null and b/backup/deblur/src/__pycache__/template.cpython-37.pyc differ diff --git a/backup/deblur/src/__pycache__/train.cpython-37.pyc b/backup/deblur/src/__pycache__/train.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..549a16127dffa26bcb4e0d7dc02154549e0df5f0 Binary files /dev/null and b/backup/deblur/src/__pycache__/train.cpython-37.pyc differ diff --git a/backup/deblur/src/__pycache__/utils.cpython-37.pyc b/backup/deblur/src/__pycache__/utils.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..04346307434536af6d2f0994c62e8ea0e736a7f3 Binary files /dev/null and b/backup/deblur/src/__pycache__/utils.cpython-37.pyc differ diff --git a/backup/deblur/src/data/__init__.py b/backup/deblur/src/data/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c54805878990586545b176800b717d4109ee496d --- /dev/null +++ b/backup/deblur/src/data/__init__.py @@ -0,0 +1,79 @@ +"""Generic dataset loader""" + +from importlib import import_module + +from torch.utils.data import DataLoader +from torch.utils.data import SequentialSampler, RandomSampler +from torch.utils.data.distributed import DistributedSampler +from .sampler import DistributedEvalSampler + +class Data(): + def __init__(self, args): + + self.modes = ['train', 'val', 'test', 'demo'] + + self.action = { + 'train': args.do_train, + 'val': args.do_validate, + 'test': args.do_test, + 'demo': args.demo + } + + self.dataset_name = { + 'train': args.data_train, + 'val': args.data_val, + 'test': args.data_test, + 'demo': 'Demo' + } + + self.args = args + + def _get_data_loader(mode='train'): + dataset_name = self.dataset_name[mode] + dataset = import_module('data.' + dataset_name.lower()) + dataset = getattr(dataset, dataset_name)(args, mode) + + if mode == 'train': + if args.distributed: + batch_size = int(args.batch_size / args.n_GPUs) # batch size per GPU (single-node training) + sampler = DistributedSampler(dataset, shuffle=True, num_replicas=args.world_size, rank=args.rank) + num_workers = int((args.num_workers + args.n_GPUs - 1) / args.n_GPUs) # num_workers per GPU (single-node training) + else: + batch_size = args.batch_size + sampler = RandomSampler(dataset, replacement=False) + num_workers = args.num_workers + drop_last = True + + elif mode in ('val', 'test', 'demo'): + if args.distributed: + batch_size = 1 # 1 image per GPU + sampler = DistributedEvalSampler(dataset, shuffle=False, num_replicas=args.world_size, rank=args.rank) + num_workers = int((args.num_workers + args.n_GPUs - 1) / args.n_GPUs) # num_workers per GPU (single-node training) + else: + batch_size = args.n_GPUs # 1 image per GPU + sampler = SequentialSampler(dataset) + num_workers = args.num_workers + drop_last = False + + loader = DataLoader( + dataset=dataset, + batch_size=batch_size, + shuffle=False, + sampler=sampler, + num_workers=num_workers, + pin_memory=True, + drop_last=drop_last, + ) + + return loader + + self.loaders = {} + for mode in self.modes: + if self.action[mode]: + self.loaders[mode] = _get_data_loader(mode) + print('===> Loading {} dataset: {}'.format(mode, self.dataset_name[mode])) + else: + self.loaders[mode] = None + + def get_loader(self): + return self.loaders diff --git a/backup/deblur/src/data/__pycache__/__init__.cpython-37.pyc b/backup/deblur/src/data/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bede98a855afc55cb03f871d1c2e5a9d2dca6743 Binary files /dev/null and b/backup/deblur/src/data/__pycache__/__init__.cpython-37.pyc differ diff --git a/backup/deblur/src/data/__pycache__/common.cpython-37.pyc b/backup/deblur/src/data/__pycache__/common.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..903f4be7565ee8bf5071f0843c9d5ddfd9d47310 Binary files /dev/null and b/backup/deblur/src/data/__pycache__/common.cpython-37.pyc differ diff --git a/backup/deblur/src/data/__pycache__/dataset.cpython-37.pyc b/backup/deblur/src/data/__pycache__/dataset.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2c4656e0a854637aae9c32692df0a61c20721e4e Binary files /dev/null and b/backup/deblur/src/data/__pycache__/dataset.cpython-37.pyc differ diff --git a/backup/deblur/src/data/__pycache__/gopro_large.cpython-37.pyc b/backup/deblur/src/data/__pycache__/gopro_large.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..93a372740468988a3b6dcd1878bf86c4ee93c5c4 Binary files /dev/null and b/backup/deblur/src/data/__pycache__/gopro_large.cpython-37.pyc differ diff --git a/backup/deblur/src/data/__pycache__/sampler.cpython-37.pyc b/backup/deblur/src/data/__pycache__/sampler.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cd65b93975916e68ec8813577a4cc26972d3c641 Binary files /dev/null and b/backup/deblur/src/data/__pycache__/sampler.cpython-37.pyc differ diff --git a/backup/deblur/src/data/common.py b/backup/deblur/src/data/common.py new file mode 100644 index 0000000000000000000000000000000000000000..96f5c4e4704308ba139c35093e50275fe1eafa71 --- /dev/null +++ b/backup/deblur/src/data/common.py @@ -0,0 +1,165 @@ +import random +import numpy as np +from skimage.color import rgb2hsv, hsv2rgb +# from skimage.transform import pyramid_gaussian + +import torch + +def _apply(func, x): + + if isinstance(x, (list, tuple)): + return [_apply(func, x_i) for x_i in x] + elif isinstance(x, dict): + y = {} + for key, value in x.items(): + y[key] = _apply(func, value) + return y + else: + return func(x) + +def crop(*args, ps=256): # patch_size + # args = [input, target] + def _get_shape(*args): + if isinstance(args[0], (list, tuple)): + return _get_shape(args[0][0]) + elif isinstance(args[0], dict): + return _get_shape(list(args[0].values())[0]) + else: + return args[0].shape + + h, w, _ = _get_shape(args) + + py = random.randrange(0, h-ps+1) + px = random.randrange(0, w-ps+1) + + def _crop(img): + if img.ndim == 2: + return img[py:py+ps, px:px+ps, np.newaxis] + else: + return img[py:py+ps, px:px+ps, :] + + return _apply(_crop, args) + +def add_noise(*args, sigma_sigma=2, rgb_range=255): + + if len(args) == 1: # usually there is only a single input + args = args[0] + + sigma = np.random.normal() * sigma_sigma * rgb_range/255 + + def _add_noise(img): + noise = np.random.randn(*img.shape).astype(np.float32) * sigma + return (img + noise).clip(0, rgb_range) + + return _apply(_add_noise, args) + +def augment(*args, hflip=True, rot=True, shuffle=True, change_saturation=True, rgb_range=255): + """augmentation consistent to input and target""" + + choices = (False, True) + + hflip = hflip and random.choice(choices) + vflip = rot and random.choice(choices) + rot90 = rot and random.choice(choices) + # shuffle = shuffle + + if shuffle: + rgb_order = list(range(3)) + random.shuffle(rgb_order) + if rgb_order == list(range(3)): + shuffle = False + + if change_saturation: + amp_factor = np.random.uniform(0.5, 1.5) + + def _augment(img): + if hflip: img = img[:, ::-1, :] + if vflip: img = img[::-1, :, :] + if rot90: img = img.transpose(1, 0, 2) + if shuffle and img.ndim > 2: + if img.shape[-1] == 3: # RGB image only + img = img[..., rgb_order] + + if change_saturation: + hsv_img = rgb2hsv(img) + hsv_img[..., 1] *= amp_factor + + img = hsv2rgb(hsv_img).clip(0, 1) * rgb_range + + return img.astype(np.float32) + + return _apply(_augment, args) + +def pad(img, divisor=4, pad_width=None, negative=False): + + def _pad_numpy(img, divisor=4, pad_width=None, negative=False): + if pad_width is None: + (h, w, _) = img.shape + pad_h = -h % divisor + pad_w = -w % divisor + pad_width = ((0, pad_h), (0, pad_w), (0, 0)) + + img = np.pad(img, pad_width, mode='edge') + + return img, pad_width + + def _pad_tensor(img, divisor=4, pad_width=None, negative=False): + + n, c, h, w = img.shape + if pad_width is None: + pad_h = -h % divisor + pad_w = -w % divisor + pad_width = (0, pad_w, 0, pad_h) + else: + try: + pad_h = pad_width[0][1] + pad_w = pad_width[1][1] + if isinstance(pad_h, torch.Tensor): + pad_h = pad_h.item() + if isinstance(pad_w, torch.Tensor): + pad_w = pad_w.item() + + pad_width = (0, pad_w, 0, pad_h) + except: + pass + + if negative: + pad_width = [-val for val in pad_width] + + img = torch.nn.functional.pad(img, pad_width, 'reflect') + + return img, pad_width + + if isinstance(img, np.ndarray): + return _pad_numpy(img, divisor, pad_width, negative) + else: # torch.Tensor + return _pad_tensor(img, divisor, pad_width, negative) + +def generate_pyramid(*args, n_scales): + + def _generate_pyramid(img): + if img.dtype != np.float32: + img = img.astype(np.float32) + # pyramid = list(pyramid_gaussian(img, n_scales-1, multichannel=True)) + # bypass pyramid, deliver the image as is + pyramid = [img] + + return pyramid + + return _apply(_generate_pyramid, args) + +def np2tensor(*args, rgb_range=255): + def _np2tensor(x): + np_transpose = np.ascontiguousarray(x.transpose(2, 0, 1)) + tensor = torch.from_numpy(np_transpose).float() + tensor.mul_(rgb_range / 255) + return tensor + + return _apply(_np2tensor, args) + +def to(*args, device=None, dtype=torch.float): + + def _to(x): + return x.to(device=device, dtype=dtype, non_blocking=True, copy=False) + + return _apply(_to, args) diff --git a/backup/deblur/src/data/dataset.py b/backup/deblur/src/data/dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..c792f96f64e288983d3600f93f91f365b25fcb41 --- /dev/null +++ b/backup/deblur/src/data/dataset.py @@ -0,0 +1,154 @@ +import os +import random +import imageio +import numpy as np +import torch.utils.data as data + +from data import common + +from utils import interact + +class Dataset(data.Dataset): + """Basic dataloader class + """ + def __init__(self, args, mode='train'): + super(Dataset, self).__init__() + self.args = args + self.mode = mode + + self.modes = () + self.set_modes() + self._check_mode() + + self.set_keys() + + if self.mode == 'train': + dataset = args.data_train + elif self.mode == 'val': + dataset = args.data_val + elif self.mode == 'test': + dataset = args.data_test + elif self.mode == 'demo': + pass + else: + raise NotImplementedError('not implemented for this mode: {}!'.format(self.mode)) + + if self.mode == 'demo': + self.subset_root = args.demo_input_dir + else: + self.subset_root = os.path.join(args.data_root, dataset, self.mode) + + self.blur_list = [] + self.sharp_list = [] + + self._scan() + + def set_modes(self): + self.modes = ('train', 'val', 'test', 'demo') + + def _check_mode(self): + """Should be called in the child class __init__() after super + """ + if self.mode not in self.modes: + raise NotImplementedError('mode error: not for {}'.format(self.mode)) + + return + + def set_keys(self): + self.blur_key = 'blur' # to be overwritten by child class + self.sharp_key = 'sharp' # to be overwritten by child class + + self.non_blur_keys = [] + self.non_sharp_keys = [] + + return + + def _scan(self, root=None): + """Should be called in the child class __init__() after super + """ + if root is None: + root = self.subset_root + + if self.blur_key in self.non_blur_keys: + self.non_blur_keys.remove(self.blur_key) + if self.sharp_key in self.non_sharp_keys: + self.non_sharp_keys.remove(self.sharp_key) + + def _key_check(path, true_key, false_keys): + path = os.path.join(path, '') + if path.find(true_key) >= 0: + for false_key in false_keys: + if path.find(false_key) >= 0: + return False + + return True + else: + return False + + def _get_list_by_key(root, true_key, false_keys): + data_list = [] + for sub, dirs, files in os.walk(root): + if not dirs: + file_list = [os.path.join(sub, f) for f in files] + if _key_check(sub, true_key, false_keys): + data_list += file_list + + data_list.sort() + + return data_list + + def _rectify_keys(): + self.blur_key = os.path.join(self.blur_key, '') + self.non_blur_keys = [os.path.join(non_blur_key, '') for non_blur_key in self.non_blur_keys] + self.sharp_key = os.path.join(self.sharp_key, '') + self.non_sharp_keys = [os.path.join(non_sharp_key, '') for non_sharp_key in self.non_sharp_keys] + + _rectify_keys() + + self.blur_list = _get_list_by_key(root, self.blur_key, self.non_blur_keys) + self.sharp_list = _get_list_by_key(root, self.sharp_key, self.non_sharp_keys) + + if len(self.sharp_list) > 0: + assert(len(self.blur_list) == len(self.sharp_list)) + + return + + def __getitem__(self, idx): + + blur = imageio.imread(self.blur_list[idx], pilmode='RGB') + if len(self.sharp_list) > 0: + sharp = imageio.imread(self.sharp_list[idx], pilmode='RGB') + imgs = [blur, sharp] + else: + imgs = [blur] + + pad_width = 0 # dummy value + if self.mode == 'train': + imgs = common.crop(*imgs, ps=self.args.patch_size) + if self.args.augment: + imgs = common.augment(*imgs, hflip=True, rot=True, shuffle=True, change_saturation=True, rgb_range=self.args.rgb_range) + imgs[0] = common.add_noise(imgs[0], sigma_sigma=2, rgb_range=self.args.rgb_range) + elif self.mode == 'demo': + imgs[0], pad_width = common.pad(imgs[0], divisor=2**(self.args.n_scales-1)) # pad in case of non-divisible size + else: + pass # deliver test image as is. + + if self.args.gaussian_pyramid: + imgs = common.generate_pyramid(*imgs, n_scales=self.args.n_scales) + + imgs = common.np2tensor(*imgs, rgb_range=self.args.rgb_range) + relpath = os.path.relpath(self.blur_list[idx], self.subset_root) + + blur = imgs[0] + sharp = imgs[1] if len(imgs) > 1 else False + + return blur, sharp, pad_width, idx, relpath + + def __len__(self): + return len(self.blur_list) + # return 32 + + + + + diff --git a/backup/deblur/src/data/demo.py b/backup/deblur/src/data/demo.py new file mode 100644 index 0000000000000000000000000000000000000000..fe87ccae62dc2f2925c2005d200feac63e28853c --- /dev/null +++ b/backup/deblur/src/data/demo.py @@ -0,0 +1,22 @@ +from data.dataset import Dataset + +from utils import interact + +class Demo(Dataset): + """Demo train, test subset class + """ + def __init__(self, args, mode='demo'): + super(Demo, self).__init__(args, mode) + + def set_modes(self): + self.modes = ('demo') + + def set_keys(self): + super(Demo, self).set_keys() + self.blur_key = '' # all the files + self.non_sharp_keys = [''] # no files + + def __getitem__(self, idx): + blur, sharp, pad_width, idx, relpath = super(Demo, self).__getitem__(idx) + + return blur, sharp, pad_width, idx, relpath diff --git a/backup/deblur/src/data/gopro_large.py b/backup/deblur/src/data/gopro_large.py new file mode 100644 index 0000000000000000000000000000000000000000..a09eb0bfffaf261ff9b9f43a57bddf32bfc62ebb --- /dev/null +++ b/backup/deblur/src/data/gopro_large.py @@ -0,0 +1,23 @@ +from data.dataset import Dataset + +from utils import interact + +class GOPRO_Large(Dataset): + """GOPRO_Large train, test subset class + """ + def __init__(self, args, mode='train'): + super(GOPRO_Large, self).__init__(args, mode) + + def set_modes(self): + self.modes = ('train', 'test') + + def set_keys(self): + super(GOPRO_Large, self).set_keys() + self.blur_key = 'blur_gamma' + # self.sharp_key = 'sharp' + + def __getitem__(self, idx): + blur, sharp, pad_width, idx, relpath = super(GOPRO_Large, self).__getitem__(idx) + relpath = relpath.replace('{}/'.format(self.blur_key), '') + + return blur, sharp, pad_width, idx, relpath diff --git a/backup/deblur/src/data/reds.py b/backup/deblur/src/data/reds.py new file mode 100644 index 0000000000000000000000000000000000000000..abebd21fd3f3f1615fa420e35ccd720f3ea4edad --- /dev/null +++ b/backup/deblur/src/data/reds.py @@ -0,0 +1,28 @@ +from data.dataset import Dataset + +from utils import interact + +class REDS(Dataset): + """REDS train, val, test subset class + """ + def __init__(self, args, mode='train'): + super(REDS, self).__init__(args, mode) + + def set_modes(self): + self.modes = ('train', 'val', 'test') + + def set_keys(self): + super(REDS, self).set_keys() + # self.blur_key = 'blur' + # self.sharp_key = 'sharp' + + self.non_blur_keys = ['blur', 'blur_comp', 'blur_bicubic'] + self.non_blur_keys.remove(self.blur_key) + self.non_sharp_keys = ['sharp_bicubic', 'sharp'] + self.non_sharp_keys.remove(self.sharp_key) + + def __getitem__(self, idx): + blur, sharp, pad_width, idx, relpath = super(REDS, self).__getitem__(idx) + relpath = relpath.replace('{}/{}/'.format(self.mode, self.blur_key), '') + + return blur, sharp, pad_width, idx, relpath diff --git a/backup/deblur/src/data/sampler.py b/backup/deblur/src/data/sampler.py new file mode 100644 index 0000000000000000000000000000000000000000..ad03889cb4acd05b93905b49a9fb45e6ebc8d8dc --- /dev/null +++ b/backup/deblur/src/data/sampler.py @@ -0,0 +1,115 @@ +import math +import torch +from torch.utils.data import Sampler +import torch.distributed as dist + + +class DistributedEvalSampler(Sampler): + r""" + DistributedEvalSampler is different from DistributedSampler. + It does NOT add extra samples to make it evenly divisible. + DistributedEvalSampler should NOT be used for training. The distributed processes could hang forever. + See this issue for details: https://github.com/pytorch/pytorch/issues/22584 + shuffle is disabled by default + + DistributedEvalSampler is for evaluation purpose where synchronization does not happen every epoch. + Synchronization should be done outside the dataloader loop. + + Sampler that restricts data loading to a subset of the dataset. + + It is especially useful in conjunction with + :class:`torch.nn.parallel.DistributedDataParallel`. In such a case, each + process can pass a :class`~torch.utils.data.DistributedSampler` instance as a + :class:`~torch.utils.data.DataLoader` sampler, and load a subset of the + original dataset that is exclusive to it. + + .. note:: + Dataset is assumed to be of constant size. + + Arguments: + dataset: Dataset used for sampling. + num_replicas (int, optional): Number of processes participating in + distributed training. By default, :attr:`rank` is retrieved from the + current distributed group. + rank (int, optional): Rank of the current process within :attr:`num_replicas`. + By default, :attr:`rank` is retrieved from the current distributed + group. + shuffle (bool, optional): If ``True`` (default), sampler will shuffle the + indices. + seed (int, optional): random seed used to shuffle the sampler if + :attr:`shuffle=True`. This number should be identical across all + processes in the distributed group. Default: ``0``. + + .. warning:: + In distributed mode, calling the :meth`set_epoch(epoch) ` method at + the beginning of each epoch **before** creating the :class:`DataLoader` iterator + is necessary to make shuffling work properly across multiple epochs. Otherwise, + the same ordering will be always used. + + Example:: + + >>> sampler = DistributedSampler(dataset) if is_distributed else None + >>> loader = DataLoader(dataset, shuffle=(sampler is None), + ... sampler=sampler) + >>> for epoch in range(start_epoch, n_epochs): + ... if is_distributed: + ... sampler.set_epoch(epoch) + ... train(loader) + """ + + def __init__(self, dataset, num_replicas=None, rank=None, shuffle=False, seed=0): + if num_replicas is None: + if not dist.is_available(): + raise RuntimeError("Requires distributed package to be available") + num_replicas = dist.get_world_size() + if rank is None: + if not dist.is_available(): + raise RuntimeError("Requires distributed package to be available") + rank = dist.get_rank() + self.dataset = dataset + self.num_replicas = num_replicas + self.rank = rank + self.epoch = 0 + # self.num_samples = int(math.ceil(len(self.dataset) * 1.0 / self.num_replicas)) + # self.total_size = self.num_samples * self.num_replicas + self.total_size = len(self.dataset) # true value without extra samples + indices = list(range(self.total_size)) + indices = indices[self.rank:self.total_size:self.num_replicas] + self.num_samples = len(indices) # true value without extra samples + + self.shuffle = shuffle + self.seed = seed + + def __iter__(self): + if self.shuffle: + # deterministically shuffle based on epoch and seed + g = torch.Generator() + g.manual_seed(self.seed + self.epoch) + indices = torch.randperm(len(self.dataset), generator=g).tolist() + else: + indices = list(range(len(self.dataset))) + + + # # add extra samples to make it evenly divisible + # indices += indices[:(self.total_size - len(indices))] + # assert len(indices) == self.total_size + + # subsample + indices = indices[self.rank:self.total_size:self.num_replicas] + assert len(indices) == self.num_samples + + return iter(indices) + + def __len__(self): + return self.num_samples + + def set_epoch(self, epoch): + r""" + Sets the epoch for this sampler. When :attr:`shuffle=True`, this ensures all replicas + use a different random ordering for each epoch. Otherwise, the next iteration of this + sampler will yield the same ordering. + + Arguments: + epoch (int): _epoch number. + """ + self.epoch = epoch diff --git a/backup/deblur/src/experiment/LamRes_L1/events.out.tfevents.1604581902.gpu25.cse.cuhk.edu.hk.67456.0 b/backup/deblur/src/experiment/LamRes_L1/events.out.tfevents.1604581902.gpu25.cse.cuhk.edu.hk.67456.0 new file mode 100644 index 0000000000000000000000000000000000000000..0e147c0332a926de40a89425fd4762061c654d89 --- /dev/null +++ b/backup/deblur/src/experiment/LamRes_L1/events.out.tfevents.1604581902.gpu25.cse.cuhk.edu.hk.67456.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8a9ae0d261911405cce7945eb9771323408327aacecc966029ae25e34bb43346 +size 40625021 diff --git a/backup/deblur/src/experiment/LamRes_L1/events.out.tfevents.1604586254.gpu25.cse.cuhk.edu.hk.81508.0 b/backup/deblur/src/experiment/LamRes_L1/events.out.tfevents.1604586254.gpu25.cse.cuhk.edu.hk.81508.0 new file mode 100644 index 0000000000000000000000000000000000000000..bb48f45af50258ccd6272736eece91343229f5a4 --- /dev/null +++ b/backup/deblur/src/experiment/LamRes_L1/events.out.tfevents.1604586254.gpu25.cse.cuhk.edu.hk.81508.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ad3ea4a7f1c04500b92afb0103be7d776b1e4ea54e7de443d6fba538aef2f3c5 +size 10677492 diff --git a/backup/deblur/src/experiment/LamRes_L1/events.out.tfevents.1604588144.gpu25.cse.cuhk.edu.hk.86000.0 b/backup/deblur/src/experiment/LamRes_L1/events.out.tfevents.1604588144.gpu25.cse.cuhk.edu.hk.86000.0 new file mode 100644 index 0000000000000000000000000000000000000000..0cc5f5a83aeed6efdcdfac506cd88558a29275f4 --- /dev/null +++ b/backup/deblur/src/experiment/LamRes_L1/events.out.tfevents.1604588144.gpu25.cse.cuhk.edu.hk.86000.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f846d2f48815f3b754e06ac1aba07ea58cd60c84dacb945f5fc003311bcb1f45 +size 40 diff --git a/backup/deblur/src/experiment/LamRes_L1/events.out.tfevents.1604588391.gpu25.cse.cuhk.edu.hk.87292.0 b/backup/deblur/src/experiment/LamRes_L1/events.out.tfevents.1604588391.gpu25.cse.cuhk.edu.hk.87292.0 new file mode 100644 index 0000000000000000000000000000000000000000..1e90c418ebbe2fce5eb0750442ee518e5608f4f8 --- /dev/null +++ b/backup/deblur/src/experiment/LamRes_L1/events.out.tfevents.1604588391.gpu25.cse.cuhk.edu.hk.87292.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3011b3cabbd07a76e27351e1948c0c21d1406f0d1a8cecda9fe588f5f8073304 +size 40 diff --git a/backup/deblur/src/experiment/LamRes_L1/events.out.tfevents.1604588569.gpu25.cse.cuhk.edu.hk.87845.0 b/backup/deblur/src/experiment/LamRes_L1/events.out.tfevents.1604588569.gpu25.cse.cuhk.edu.hk.87845.0 new file mode 100644 index 0000000000000000000000000000000000000000..4be7333d7595342e6314fab1bf387fb47e9634da --- /dev/null +++ b/backup/deblur/src/experiment/LamRes_L1/events.out.tfevents.1604588569.gpu25.cse.cuhk.edu.hk.87845.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e56fa7a8100b2b1dd1209e1f8dc328c0ee40bb707b13cbd10ae34d611a1fd7a3 +size 1514461 diff --git a/backup/deblur/src/experiment/LamRes_L1/events.out.tfevents.1604589124.gpu25.cse.cuhk.edu.hk.88580.0 b/backup/deblur/src/experiment/LamRes_L1/events.out.tfevents.1604589124.gpu25.cse.cuhk.edu.hk.88580.0 new file mode 100644 index 0000000000000000000000000000000000000000..3efc075d59e07068dcb3a91373903b6183f54576 --- /dev/null +++ b/backup/deblur/src/experiment/LamRes_L1/events.out.tfevents.1604589124.gpu25.cse.cuhk.edu.hk.88580.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fdaf8cde8cda24d3c216ebc285d586f2b14703a46e3f167952e80fae3deeca16 +size 374717989 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6/events.out.tfevents.1604934203.gpu1.cse.cuhk.edu.hk.267742.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6/events.out.tfevents.1604934203.gpu1.cse.cuhk.edu.hk.267742.0 new file mode 100644 index 0000000000000000000000000000000000000000..c376a7b18006f15960e76690665f6a237298cb2c --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6/events.out.tfevents.1604934203.gpu1.cse.cuhk.edu.hk.267742.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0c13f506826fb0d09f29006b467815dd315594493e9c23cb9f73fa80593c3b2e +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6/events.out.tfevents.1604934340.gpu1.cse.cuhk.edu.hk.268009.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6/events.out.tfevents.1604934340.gpu1.cse.cuhk.edu.hk.268009.0 new file mode 100644 index 0000000000000000000000000000000000000000..ba578b60367aa04b5f1034d684c07ef9abe1c646 --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6/events.out.tfevents.1604934340.gpu1.cse.cuhk.edu.hk.268009.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bb72d181d6fd7b117f2ced5226ca88ec8768990b78654f28eee8e9e47f8c950d +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6/events.out.tfevents.1604934514.gpu1.cse.cuhk.edu.hk.268265.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6/events.out.tfevents.1604934514.gpu1.cse.cuhk.edu.hk.268265.0 new file mode 100644 index 0000000000000000000000000000000000000000..7a3db3fda574ae327d19dc74a957a564314745ba --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6/events.out.tfevents.1604934514.gpu1.cse.cuhk.edu.hk.268265.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9528f9d1e9f0d52ae03f3662fd7934ca4ca140d2d00b7b2f25ea5bf02b3736d3 +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6/events.out.tfevents.1604934608.gpu1.cse.cuhk.edu.hk.268451.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6/events.out.tfevents.1604934608.gpu1.cse.cuhk.edu.hk.268451.0 new file mode 100644 index 0000000000000000000000000000000000000000..e70b7f373f6d726d0e059767afedfda99b91d6a5 --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6/events.out.tfevents.1604934608.gpu1.cse.cuhk.edu.hk.268451.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:635649c2ab4184cba576961c84a57fcea8377f912fec6989d2161d33f74dc128 +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6/events.out.tfevents.1604934728.gpu1.cse.cuhk.edu.hk.268742.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6/events.out.tfevents.1604934728.gpu1.cse.cuhk.edu.hk.268742.0 new file mode 100644 index 0000000000000000000000000000000000000000..05f023c8022c8042a26b704263d9967e405361a0 --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6/events.out.tfevents.1604934728.gpu1.cse.cuhk.edu.hk.268742.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:458b3b3d676b362f1469768f7d2bad5b06cc2748b4b68dd08534e680d28a0e0b +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6_rtx/events.out.tfevents.1604936786.gpu54.cse.cuhk.edu.hk.33807.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6_rtx/events.out.tfevents.1604936786.gpu54.cse.cuhk.edu.hk.33807.0 new file mode 100644 index 0000000000000000000000000000000000000000..4a3c0886391689dd7f7c40481e4c22004ec314a1 --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6_rtx/events.out.tfevents.1604936786.gpu54.cse.cuhk.edu.hk.33807.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a85e4283fedf50e782991b34450485be7b67ae211e7b3e951453cee86d5f2481 +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6_rtx/events.out.tfevents.1604936996.gpu54.cse.cuhk.edu.hk.33970.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6_rtx/events.out.tfevents.1604936996.gpu54.cse.cuhk.edu.hk.33970.0 new file mode 100644 index 0000000000000000000000000000000000000000..6cda4fef66c03aedeefd74102a7984a34f0cf8e6 --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6_rtx/events.out.tfevents.1604936996.gpu54.cse.cuhk.edu.hk.33970.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:69e96923c09721cf331e59120b369259c024fcb88c1fe31b554a04e9d5531577 +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6_rtx/events.out.tfevents.1604937178.gpu54.cse.cuhk.edu.hk.34120.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6_rtx/events.out.tfevents.1604937178.gpu54.cse.cuhk.edu.hk.34120.0 new file mode 100644 index 0000000000000000000000000000000000000000..8b4bf2f9d00c8293ec47b698686d44d4d1a605c8 --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6_rtx/events.out.tfevents.1604937178.gpu54.cse.cuhk.edu.hk.34120.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d809142cbd3d51df9a4d4cda26f7ba2f5ecaf1b38d5c28a42804a937b500fffd +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6_rtx/events.out.tfevents.1604937291.gpu54.cse.cuhk.edu.hk.34212.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6_rtx/events.out.tfevents.1604937291.gpu54.cse.cuhk.edu.hk.34212.0 new file mode 100644 index 0000000000000000000000000000000000000000..4d2a6b898ba2d93ddaf93f18bc792ccded4be72f --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6_rtx/events.out.tfevents.1604937291.gpu54.cse.cuhk.edu.hk.34212.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f2be0af548f3284b00179e905732cb406cfa4d7f6b6850d7cc73f51c18ebfd8a +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6_rtx/events.out.tfevents.1604937341.gpu54.cse.cuhk.edu.hk.34282.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6_rtx/events.out.tfevents.1604937341.gpu54.cse.cuhk.edu.hk.34282.0 new file mode 100644 index 0000000000000000000000000000000000000000..abef49e1a500dd777cad8c81521403316954f753 --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6_rtx/events.out.tfevents.1604937341.gpu54.cse.cuhk.edu.hk.34282.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f95c770b93c50cf591bc93f245b855ddd25c12f044345c388920d5255a8b790a +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6_rtx/events.out.tfevents.1604937398.gpu54.cse.cuhk.edu.hk.34368.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6_rtx/events.out.tfevents.1604937398.gpu54.cse.cuhk.edu.hk.34368.0 new file mode 100644 index 0000000000000000000000000000000000000000..26ce0d63983d9a6245d95b02a2aacb1fde3d53e9 --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6_rtx/events.out.tfevents.1604937398.gpu54.cse.cuhk.edu.hk.34368.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3eba9aba3f4a5469364c6d6f62476ab33280cc66ea06147cc4721af7ffd7c5ba +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935521.gpu1.cse.cuhk.edu.hk.269617.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935521.gpu1.cse.cuhk.edu.hk.269617.0 new file mode 100644 index 0000000000000000000000000000000000000000..605b23796f0bb7757019c8c58a20e9179e4ad923 --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935521.gpu1.cse.cuhk.edu.hk.269617.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2e8500008a2d7cd7e6048cc2d653388353922019110f3533b766f9d90c43bb64 +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935580.gpu1.cse.cuhk.edu.hk.269856.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935580.gpu1.cse.cuhk.edu.hk.269856.0 new file mode 100644 index 0000000000000000000000000000000000000000..0bcb1f725abe85d28a0ed7d685abc0cc0f199393 --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935580.gpu1.cse.cuhk.edu.hk.269856.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:07beaf6b1db1790236f51dc32b06a98e5ada4d6cab9d5e148091280bc9cb23d9 +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935609.gpu1.cse.cuhk.edu.hk.269984.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935609.gpu1.cse.cuhk.edu.hk.269984.0 new file mode 100644 index 0000000000000000000000000000000000000000..ac23a72eab99ebf1830669043c190fd74a90d82f --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935609.gpu1.cse.cuhk.edu.hk.269984.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3785989fe8f699dcda6653bb71462e573b8789fbb59f99ae9b1aaeecb8eb641d +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935664.gpu1.cse.cuhk.edu.hk.270135.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935664.gpu1.cse.cuhk.edu.hk.270135.0 new file mode 100644 index 0000000000000000000000000000000000000000..4353d031b2ca100c79f610e8263d8ac9d078c798 --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935664.gpu1.cse.cuhk.edu.hk.270135.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9e8b7da9fcae727b702128e07ccbc5320d4fb1736b6ff55687e12d25b5b1e9c7 +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935766.gpu1.cse.cuhk.edu.hk.346.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935766.gpu1.cse.cuhk.edu.hk.346.0 new file mode 100644 index 0000000000000000000000000000000000000000..9291edfb047e22dc38ff7bd164cd252cfaee16de --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935766.gpu1.cse.cuhk.edu.hk.346.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7f3895adc6e43f836184936a154deed042c4195ac0058e96f413ccc33ca95e7b +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935825.gpu1.cse.cuhk.edu.hk.546.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935825.gpu1.cse.cuhk.edu.hk.546.0 new file mode 100644 index 0000000000000000000000000000000000000000..55d77e2e63a8b66d143442d4e1de1840dad0cd4d --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935825.gpu1.cse.cuhk.edu.hk.546.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:396ff2c00b6ed1a9b254ed4676d7cbf21662b0a5446b85ba6f3f1c5d7300c862 +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935866.gpu1.cse.cuhk.edu.hk.719.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935866.gpu1.cse.cuhk.edu.hk.719.0 new file mode 100644 index 0000000000000000000000000000000000000000..1d4c0971bf5abe2fbcf7bc7b6b8dae679074e8b4 --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935866.gpu1.cse.cuhk.edu.hk.719.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c9ff1a031fca82363fd2d875111a9333445082da2ae86b9cb6b1e3ecaceb454f +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935894.gpu1.cse.cuhk.edu.hk.855.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935894.gpu1.cse.cuhk.edu.hk.855.0 new file mode 100644 index 0000000000000000000000000000000000000000..8a074d921ffb19e79e564965192c6e8cd0fce115 --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935894.gpu1.cse.cuhk.edu.hk.855.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9b852cd9a4b462b7d94aa96f86a34007c0f21bb4c5634ebd2c75a245bbf016da +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935911.gpu1.cse.cuhk.edu.hk.987.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935911.gpu1.cse.cuhk.edu.hk.987.0 new file mode 100644 index 0000000000000000000000000000000000000000..1b0bbd74e334bfb6ee6a93349f4a705d1d513fdb --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604935911.gpu1.cse.cuhk.edu.hk.987.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c1d0e103cacea957571d5c8da2d3e9dfa20c00f34f77630d77a4ab4cc49f9ca4 +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604936001.gpu1.cse.cuhk.edu.hk.1275.0 b/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604936001.gpu1.cse.cuhk.edu.hk.1275.0 new file mode 100644 index 0000000000000000000000000000000000000000..4b4a1ad3f1cad0765aa3b6ab673b65062ef5e42e --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_L1_R6_test/events.out.tfevents.1604936001.gpu1.cse.cuhk.edu.hk.1275.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e54c1652332f47ce91dfd6c7de65fba94dd077885c805e8c25cb02ae464fba12 +size 85014204 diff --git a/backup/deblur/src/experiment/RAFTNET_MSE_R5_rtx/events.out.tfevents.1604937549.gpu54.cse.cuhk.edu.hk.34468.0 b/backup/deblur/src/experiment/RAFTNET_MSE_R5_rtx/events.out.tfevents.1604937549.gpu54.cse.cuhk.edu.hk.34468.0 new file mode 100644 index 0000000000000000000000000000000000000000..2138b057bd54656c125d60d3d0d95e59d81ba381 --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_MSE_R5_rtx/events.out.tfevents.1604937549.gpu54.cse.cuhk.edu.hk.34468.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9364ad10fb9cac44cc05b9258eeb22cc46ae4fe2d5339b28f18a0153f1f7440d +size 40 diff --git a/backup/deblur/src/experiment/RAFTNET_MSE_R5_rtx/events.out.tfevents.1604937798.gpu54.cse.cuhk.edu.hk.34722.0 b/backup/deblur/src/experiment/RAFTNET_MSE_R5_rtx/events.out.tfevents.1604937798.gpu54.cse.cuhk.edu.hk.34722.0 new file mode 100644 index 0000000000000000000000000000000000000000..eaca8edc6997d733c1e04673aec660360bc97e1b --- /dev/null +++ b/backup/deblur/src/experiment/RAFTNET_MSE_R5_rtx/events.out.tfevents.1604937798.gpu54.cse.cuhk.edu.hk.34722.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5e0fcb8f6fc31b6b0c14ed80b24dde2ebb3288a781a5853a61e35f9040f6407c +size 37198340 diff --git a/backup/deblur/src/experiment/RecLamRes_MSE/events.out.tfevents.1604587993.gpu57.cse.cuhk.edu.hk.9843.0 b/backup/deblur/src/experiment/RecLamRes_MSE/events.out.tfevents.1604587993.gpu57.cse.cuhk.edu.hk.9843.0 new file mode 100644 index 0000000000000000000000000000000000000000..a383da3f00c9ec3989ff60a5c8a6f910f8ba16ba --- /dev/null +++ b/backup/deblur/src/experiment/RecLamRes_MSE/events.out.tfevents.1604587993.gpu57.cse.cuhk.edu.hk.9843.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ebb7c7be1638bf041fd0d0347a6c4f4e2fb806b44b36ccf046c487da4d9bcede +size 119918313 diff --git a/backup/deblur/src/experiment/RecLamRes_MSE_Revert/events.out.tfevents.1604766669.gpu42.cse.cuhk.edu.hk.5151.0 b/backup/deblur/src/experiment/RecLamRes_MSE_Revert/events.out.tfevents.1604766669.gpu42.cse.cuhk.edu.hk.5151.0 new file mode 100644 index 0000000000000000000000000000000000000000..51f2fd6b8c10dc0c0ca6a457b6baf18ffbc78066 --- /dev/null +++ b/backup/deblur/src/experiment/RecLamRes_MSE_Revert/events.out.tfevents.1604766669.gpu42.cse.cuhk.edu.hk.5151.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:40900366006124cf1ab0b14ee9ce133bf1821eea15e4a84bf2559e22aaaaccc8 +size 40 diff --git a/backup/deblur/src/experiment/RecLamRes_MSE_detach/events.out.tfevents.1604624472.gpu1.cse.cuhk.edu.hk.16896.0 b/backup/deblur/src/experiment/RecLamRes_MSE_detach/events.out.tfevents.1604624472.gpu1.cse.cuhk.edu.hk.16896.0 new file mode 100644 index 0000000000000000000000000000000000000000..3bfec978551c133b05378c151ab90d6b3a9a1ee1 --- /dev/null +++ b/backup/deblur/src/experiment/RecLamRes_MSE_detach/events.out.tfevents.1604624472.gpu1.cse.cuhk.edu.hk.16896.0 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1b2ad4d23aea239acf56a336e5e4964a4a6f6c0917e6c76e069fac101d44587f +size 1944721 diff --git a/backup/deblur/src/lambda_networks/__init__.py b/backup/deblur/src/lambda_networks/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1db6fca5f08f0633c1980eecf47146294457a86f --- /dev/null +++ b/backup/deblur/src/lambda_networks/__init__.py @@ -0,0 +1,3 @@ +from lambda_networks.lambda_networks import LambdaLayer +from lambda_networks.rlambda_networks import RLambdaLayer +λLayer = LambdaLayer \ No newline at end of file diff --git a/backup/deblur/src/lambda_networks/__pycache__/__init__.cpython-37.pyc b/backup/deblur/src/lambda_networks/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e1d223d0a611a5b047904f3d493784607c0e799f Binary files /dev/null and b/backup/deblur/src/lambda_networks/__pycache__/__init__.cpython-37.pyc differ diff --git a/backup/deblur/src/lambda_networks/__pycache__/lambda_networks.cpython-37.pyc b/backup/deblur/src/lambda_networks/__pycache__/lambda_networks.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aaf69880a76224c9725f4d82c8fab8f555651549 Binary files /dev/null and b/backup/deblur/src/lambda_networks/__pycache__/lambda_networks.cpython-37.pyc differ diff --git a/backup/deblur/src/lambda_networks/__pycache__/rlambda_networks.cpython-37.pyc b/backup/deblur/src/lambda_networks/__pycache__/rlambda_networks.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..df9dbc0902a260730490e3d3613548fc2ea26075 Binary files /dev/null and b/backup/deblur/src/lambda_networks/__pycache__/rlambda_networks.cpython-37.pyc differ diff --git a/backup/deblur/src/lambda_networks/lambda_networks.py b/backup/deblur/src/lambda_networks/lambda_networks.py new file mode 100644 index 0000000000000000000000000000000000000000..09c599c3d85cc8027383754e0996b67c00f28c31 --- /dev/null +++ b/backup/deblur/src/lambda_networks/lambda_networks.py @@ -0,0 +1,80 @@ +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 LambdaLayer(nn.Module): + def __init__( + self, + dim, + *, + dim_k, + n = None, + r = None, + heads = 4, + dim_out = None, + dim_u = 1): + 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) + 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 diff --git a/backup/deblur/src/lambda_networks/rlambda_networks.py b/backup/deblur/src/lambda_networks/rlambda_networks.py new file mode 100644 index 0000000000000000000000000000000000000000..49f9a0ce799ac80bae1279a42cd574cddcae205e --- /dev/null +++ b/backup/deblur/src/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/backup/deblur/src/launch.py b/backup/deblur/src/launch.py new file mode 100644 index 0000000000000000000000000000000000000000..4652eefb7310efa0cb137f60d5f098652072b4ea --- /dev/null +++ b/backup/deblur/src/launch.py @@ -0,0 +1,55 @@ +""" distributed launcher adopted from torch.distributed.launch + usage example: https://github.com/facebookresearch/maskrcnn-benchmark + This enables using multiprocessing for each spawned process (as they are treated as main processes) +""" +import sys +import subprocess +from argparse import ArgumentParser, REMAINDER + +from utils import str2bool, int2str + +def parse_args(): + parser = ArgumentParser(description="PyTorch distributed training launch " + "helper utilty that will spawn up " + "multiple distributed processes") + + + parser.add_argument('--n_GPUs', type=int, default=1, help='the number of GPUs for training') + + # positional + parser.add_argument("training_script", type=str, + help="The full path to the single GPU training " + "program/script to be launched in parallel, " + "followed by all the arguments for the " + "training script") + + # rest from the training program + parser.add_argument('training_script_args', nargs=REMAINDER) + return parser.parse_args() + +def main(): + args = parse_args() + + processes = [] + for rank in range(0, args.n_GPUs): + cmd = [sys.executable] + + cmd.append(args.training_script) + cmd.extend(args.training_script_args) + + cmd += ['--distributed', 'True'] + cmd += ['--launched', 'True'] + cmd += ['--n_GPUs', str(args.n_GPUs)] + cmd += ['--rank', str(rank)] + + process = subprocess.Popen(cmd) + processes.append(process) + + for process in processes: + process.wait() + if process.returncode != 0: + raise subprocess.CalledProcessError(returncode=process.returncode, + cmd=cmd) + +if __name__ == "__main__": + main() diff --git a/backup/deblur/src/loss/__init__.py b/backup/deblur/src/loss/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c2d88915f01fc267404322ae87e3b417e7a9cf75 --- /dev/null +++ b/backup/deblur/src/loss/__init__.py @@ -0,0 +1,500 @@ +import os +from importlib import import_module + +import torch +from torch import nn +import torch.distributed as dist + +import matplotlib.pyplot as plt +plt.switch_backend('agg') # https://github.com/matplotlib/matplotlib/issues/3466 + +from .metric import PSNR, SSIM + +from utils import interact + +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): + # print(i,sr[i].max(),sr[i].min(),hr.max(),hr.min()) + 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(torch.nn.modules.loss._Loss): + def __init__(self, args, epoch=None, model=None, optimizer=None): + """ + input: + args.loss use '+' to sum over different loss functions + use '*' to specify the loss weight + + example: + 1*MSE+0.5*VGG54 + loss = sum of MSE and VGG54(weight=0.5) + + args.measure similar to args.loss, but without weight + + example: + MSE+PSNR + measure MSE and PSNR, independently + """ + super(Loss, self).__init__() + + self.args = args + + self.rgb_range = args.rgb_range + self.decay_gamma=args.decay_gamma + self.device_type = args.device_type + self.synchronized = False + + self.epoch = args.start_epoch if epoch is None else epoch + self.save_dir = args.save_dir + self.save_name = os.path.join(self.save_dir, 'loss.pt') + + # self.training = True + self.validating = False + self.testing = False + self.mode = 'train' + self.modes = ('train', 'val', 'test') + + # Loss + self.loss = nn.ModuleDict() + self.loss_types = [] + self.weight = {} + self.buffer=[0.0]*args.n_scales + + self.loss_stat = {mode:{} for mode in self.modes} + # loss_stat[mode][loss_type][epoch] = loss_value + # loss_stat[mode]['Total'][epoch] = loss_total + + for weighted_loss in args.loss.split('+'): + w, l = weighted_loss.split('*') + l = l.upper() + if l in ('ABS', 'L1'): + loss_type = 'L1' + func = nn.L1Loss() + elif l in ('MSE', 'L2'): + loss_type = 'L2' + func = nn.MSELoss() + elif l in ('ADV', 'GAN'): + loss_type = 'ADV' + m = import_module('loss.adversarial') + func = getattr(m, 'Adversarial')(args, model, optimizer) + else: + loss_type = l + m = import_module*'loss.{}'.format(l.lower()) + func = getattr(m, l)(args) + + self.loss_types += [loss_type] + self.loss[loss_type] = func + self.weight[loss_type] = float(w) + + print('Loss function: {}'.format(args.loss)) + + # Metrics + self.do_measure = args.metric.lower() != 'none' + + self.metric = nn.ModuleDict() + self.metric_types = [] + self.metric_stat = {mode:{} for mode in self.modes} + # metric_stat[mode][metric_type][epoch] = metric_value + + if self.do_measure: + for metric_type in args.metric.split(','): + metric_type = metric_type.upper() + if metric_type == 'PSNR': + metric_func = PSNR() + elif metric_type == 'SSIM': + metric_func = SSIM(args.device_type) # single precision + else: + raise NotImplementedError + + self.metric_types += [metric_type] + self.metric[metric_type] = metric_func + + print('Metrics: {}'.format(args.metric)) + + if args.start_epoch != 1: + self.load(args.start_epoch - 1) + + for mode in self.modes: + for loss_type in self.loss: + if loss_type not in self.loss_stat[mode]: + self.loss_stat[mode][loss_type] = {} # initialize loss + + if 'Total' not in self.loss_stat[mode]: + self.loss_stat[mode]['Total'] = {} + + if self.do_measure: + for metric_type in self.metric: + if metric_type not in self.metric_stat[mode]: + self.metric_stat[mode][metric_type] = {} + + self.count = 0 + self.count_m = 0 + + self.to(args.device, dtype=args.dtype) + + def train(self, mode=True): + super(Loss, self).train(mode) + if mode: + self.validating = False + self.testing = False + self.mode = 'train' + else: # default test mode + self.validating = False + self.testing = True + self.mode = 'test' + + def validate(self): + super(Loss, self).eval() + # self.training = False + self.validating = True + self.testing = False + self.mode = 'val' + + def test(self): + super(Loss, self).eval() + # self.training = False + self.validating = False + self.testing = True + self.mode = 'test' + + def forward(self, input, target): + self.synchronized = False + + loss = 0 + weights=[0.32,0.08,0.02,0.01,0.005] + if len(input)>len(weights): + for i in range(len(input)-len(weights)): + weights.append(weights[-1]*0.5) + if len(input)==1: + weights=[1.0] + weights=weights[::-1] + def _ms_forward(input, target, func): + if isinstance(input, (list, tuple)): # loss for list output + _loss,buffer_lst=sequence_loss(input,target[0],func,gamma=self.decay_gamma) + # first=func(input[0],target[0]) + # _loss = first*weights[0] + # self.buffer=[first.item()] + # for i in range(1,len(input)): + # tmp=func(input[i],target[0]) + # self.buffer.append(tmp.item()) + # _loss+=tmp*weights[i] + self.buffer=buffer_lst + return _loss + elif isinstance(input, dict): # loss for dict output + _loss = [] + for key in input: + _loss += [func(input[key], target[key])] + return sum(_loss) + else: # loss for tensor output + return func(input, target) + + # initialize + if self.count == 0: + for loss_type in self.loss_types: + self.loss_stat[self.mode][loss_type][self.epoch] = 0 + self.loss_stat[self.mode]['Total'][self.epoch] = 0 + + if isinstance(input, list): + count = input[-1].shape[0] + else: # Tensor + count = input.shape[0] # batch size + + isnan = False + for loss_type in self.loss_types: + + if loss_type == 'ADV': + _loss = self.loss[loss_type](input[-1], target[0], self.training) * self.weight[loss_type] + else: + _loss = _ms_forward(input, target, self.loss[loss_type]) * self.weight[loss_type] + + if torch.isnan(_loss): + isnan = True # skip recording (will also be skipped at backprop) + else: + self.loss_stat[self.mode][loss_type][self.epoch] += _loss.item() * count + self.loss_stat[self.mode]['Total'][self.epoch] += _loss.item() * count + + loss += _loss + + if not isnan: + self.count += count + + if not self.training and self.do_measure: + self.measure(input, target) + + return loss + + def measure(self, input, target): + if isinstance(input, (list, tuple)): + self.measure(input[-1], target[0]) + return + elif isinstance(input, dict): + first_key = list(input.keys())[0] + self.measure(input[first_key], target[first_key]) + return + else: + pass + + if self.count_m == 0: + for metric_type in self.metric_stat[self.mode]: + self.metric_stat[self.mode][metric_type][self.epoch] = 0 + + if isinstance(input, list): + count = input[-1].shape[0] + else: # Tensor + count = input.shape[0] # batch size + + for metric_type in self.metric_stat[self.mode]: + + input = input.clamp(0, self.rgb_range) # not in_place + if self.rgb_range==1: + input*=255 + target*=255 + input.round_() + target.round_() + if self.rgb_range == 255: + input.round_() + + _metric = self.metric[metric_type](input, target) + self.metric_stat[self.mode][metric_type][self.epoch] += _metric.item() * count + + self.count_m += count + + return + + def normalize(self): + if self.args.distributed: + dist.barrier() + if not self.synchronized: + self.all_reduce() + + if self.count > 0: + for loss_type in self.loss_stat[self.mode]: # including 'Total' + self.loss_stat[self.mode][loss_type][self.epoch] /= self.count + self.count = 0 + + if self.count_m > 0: + for metric_type in self.metric_stat[self.mode]: + self.metric_stat[self.mode][metric_type][self.epoch] /= self.count_m + self.count_m = 0 + + return + + def all_reduce(self, epoch=None): + # synchronize loss for distributed GPU processes + + if epoch is None: + epoch = self.epoch + + def _reduce_value(value, ReduceOp=dist.ReduceOp.SUM): + value_tensor = torch.Tensor([value]).to(self.args.device, self.args.dtype, non_blocking=True) + dist.all_reduce(value_tensor, ReduceOp, async_op=False) + value = value_tensor.item() + del value_tensor + + return value + + dist.barrier() + if self.count > 0: # I assume this should be true + self.count = _reduce_value(self.count, dist.ReduceOp.SUM) + + for loss_type in self.loss_stat[self.mode]: + self.loss_stat[self.mode][loss_type][epoch] = _reduce_value( + self.loss_stat[self.mode][loss_type][epoch], + dist.ReduceOp.SUM + ) + + if self.count_m > 0: + self.count_m = _reduce_value(self.count_m, dist.ReduceOp.SUM) + + for metric_type in self.metric_stat[self.mode]: + self.metric_stat[self.mode][metric_type][epoch] = _reduce_value( + self.metric_stat[self.mode][metric_type][epoch], + dist.ReduceOp.SUM + ) + + self.synchronized = True + + return + + def print_metrics(self): + + print(self.get_metric_desc()) + return + + def get_last_loss(self): + return self.loss_stat[self.mode]['Total'][self.epoch] + + def get_loss_desc(self): + + if self.mode == 'train': + desc_prefix = 'Train' + elif self.mode == 'val': + desc_prefix = 'Validation' + else: + desc_prefix = 'Test' + + loss = self.loss_stat[self.mode]['Total'][self.epoch] + if self.count > 0: + loss /= self.count + desc = '{} Loss: {:.1f}'.format(desc_prefix, loss) + + if self.mode in ('val', 'test'): + metric_desc = self.get_metric_desc() + desc = '{}{}'.format(desc, metric_desc) + + return desc + + def get_metric_desc(self): + desc = '' + for metric_type in self.metric_stat[self.mode]: + measured = self.metric_stat[self.mode][metric_type][self.epoch] + if self.count_m > 0: + measured /= self.count_m + + if metric_type == 'PSNR': + desc += ' {}: {:2.2f}'.format(metric_type, measured) + elif metric_type == 'SSIM': + desc += ' {}: {:1.4f}'.format(metric_type, measured) + else: + desc += ' {}: {:2.4f}'.format(metric_type, measured) + + return desc + + def step(self, plot_name=None): + self.normalize() + self.plot(plot_name) + if not self.training and self.do_measure: + # self.print_metrics() + self.plot_metric() + # self.epoch += 1 + + return + + def save(self): + + state = { + 'loss_stat': self.loss_stat, + 'metric_stat': self.metric_stat, + } + torch.save(state, self.save_name) + + return + + def load(self, epoch=None): + + print('Loading loss record from {}'.format(self.save_name)) + if os.path.exists(self.save_name): + state = torch.load(self.save_name, map_location=self.args.device) + + self.loss_stat = state['loss_stat'] + if 'metric_stat' in state: + self.metric_stat = state['metric_stat'] + else: + pass + else: + print('no loss record found for {}!'.format(self.save_name)) + + if epoch is not None: + self.epoch = epoch + + return + + def plot(self, plot_name=None, metric=False): + + self.plot_loss(plot_name) + + if metric: + self.plot_metric(plot_name) + # else: + # self.plot_loss(plot_name) + + return + + + def plot_loss(self, plot_name=None): + if plot_name is None: + plot_name = os.path.join(self.save_dir, "{}_loss.pdf".format(self.mode)) + + title = "{} loss".format(self.mode) + + fig = plt.figure() + plt.title(title) + plt.xlabel('epochs') + plt.ylabel('loss') + plt.grid(True, linestyle=':') + + for loss_type, loss_record in self.loss_stat[self.mode].items(): # including Total + axis = sorted([epoch for epoch in loss_record.keys() if epoch <= self.epoch]) + value = [self.loss_stat[self.mode][loss_type][epoch] for epoch in axis] + label = loss_type + + plt.plot(axis, value, label=label) + + plt.xlim(0, self.epoch) + plt.legend() + plt.savefig(plot_name) + plt.close(fig) + + return + + def plot_metric(self, plot_name=None): + # assume there are only max 2 metrics + if plot_name is None: + plot_name = os.path.join(self.save_dir, "{}_metric.pdf".format(self.mode)) + + title = "{} metrics".format(self.mode) + + fig, ax1 = plt.subplots() + plt.title(title) + plt.grid(True, linestyle=':') + ax1.set_xlabel('epochs') + + plots = None + for metric_type, metric_record in self.metric_stat[self.mode].items(): + axis = sorted([epoch for epoch in metric_record.keys() if epoch <= self.epoch]) + value = [metric_record[epoch] for epoch in axis] + label = metric_type + + if metric_type == 'PSNR': + ax = ax1 + color='C0' + elif metric_type == 'SSIM': + ax2 = ax1.twinx() + ax = ax2 + color='C1' + + ax.set_ylabel(metric_type) + if plots is None: + plots = ax.plot(axis, value, label=label, color=color) + else: + plots += ax.plot(axis, value, label=label, color=color) + + labels = [plot.get_label() for plot in plots] + plt.legend(plots, labels) + plt.xlim(0, self.epoch) + plt.savefig(plot_name) + plt.close(fig) + + return + + def sort(self): + # sort the loss/metric record + for mode in self.modes: + for loss_type, loss_epochs in self.loss_stat[mode].items(): + self.loss_stat[mode][loss_type] = {epoch: loss_epochs[epoch] for epoch in sorted(loss_epochs)} + + for metric_type, metric_epochs in self.metric_stat[mode].items(): + self.metric_stat[mode][metric_type] = {epoch: metric_epochs[epoch] for epoch in sorted(metric_epochs)} + + return self diff --git a/backup/deblur/src/loss/__pycache__/__init__.cpython-37.pyc b/backup/deblur/src/loss/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c4dfecaadfc37464d7218cd874feee55166650db Binary files /dev/null and b/backup/deblur/src/loss/__pycache__/__init__.cpython-37.pyc differ diff --git a/backup/deblur/src/loss/__pycache__/metric.cpython-37.pyc b/backup/deblur/src/loss/__pycache__/metric.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bf67eabf06351fa0c0d9ad32773fd2a7de95b420 Binary files /dev/null and b/backup/deblur/src/loss/__pycache__/metric.cpython-37.pyc differ diff --git a/backup/deblur/src/loss/adversarial.py b/backup/deblur/src/loss/adversarial.py new file mode 100644 index 0000000000000000000000000000000000000000..0258122f01d694f2938d2d320b22cc10c908c01f --- /dev/null +++ b/backup/deblur/src/loss/adversarial.py @@ -0,0 +1,52 @@ +import torch +import torch.nn as nn + +from utils import interact + +import torch.cuda.amp as amp + +class Adversarial(nn.modules.loss._Loss): + # pure loss function without saving & loading option + # but trains deiscriminator + def __init__(self, args, model, optimizer): + super(Adversarial, self).__init__() + self.args = args + self.model = model.model + self.optimizer = optimizer + self.scaler = amp.GradScaler( + init_scale=self.args.init_scale, + enabled=self.args.amp + ) + + self.gan_k = 1 + + self.BCELoss = nn.BCEWithLogitsLoss() + + def forward(self, fake, real, training=False): + if training: + # update discriminator + fake_detach = fake.detach() + for _ in range(self.gan_k): + self.optimizer.D.zero_grad() + # d: B x 1 tensor + with amp.autocast(self.args.amp): + d_fake = self.model.D(fake_detach) + d_real = self.model.D(real) + + label_fake = torch.zeros_like(d_fake) + label_real = torch.ones_like(d_real) + + loss_d = self.BCELoss(d_fake, label_fake) + self.BCELoss(d_real, label_real) + + self.scaler.scale(loss_d).backward(retain_graph=False) + self.scaler.step(self.optimizer.D) + self.scaler.update() + else: + d_real = self.model.D(real) + label_real = torch.ones_like(d_real) + + # update generator (outside here) + d_fake_bp = self.model.D(fake) + loss_g = self.BCELoss(d_fake_bp, label_real) + + return loss_g \ No newline at end of file diff --git a/backup/deblur/src/loss/metric.py b/backup/deblur/src/loss/metric.py new file mode 100644 index 0000000000000000000000000000000000000000..bfb5165c0cc48d843acf02558f7ea3021947d218 --- /dev/null +++ b/backup/deblur/src/loss/metric.py @@ -0,0 +1,112 @@ +# from skimage.metrics import peak_signal_noise_ratio, structural_similarity + +import torch +from torch import nn + +def _expand(img): + if img.ndim < 4: + img = img.expand([1] * (4-img.ndim) + list(img.shape)) + + return img + +class PSNR(nn.Module): + def __init__(self): + super(PSNR, self).__init__() + + def forward(self, im1, im2, data_range=None): + # tensor input, constant output + + if data_range is None: + data_range = 255 if im1.max() > 1 else 1 + + se = (im1-im2)**2 + se = _expand(se) + + mse = se.mean(dim=list(range(1, se.ndim))) + psnr = 10 * (data_range**2/mse).log10().mean() + + return psnr + +class SSIM(nn.Module): + def __init__(self, device_type='cpu', dtype=torch.float32): + super(SSIM, self).__init__() + + self.device_type = device_type + self.dtype = dtype # SSIM in half precision could be inaccurate + + def _get_ssim_weight(): + truncate = 3.5 + sigma = 1.5 + r = int(truncate * sigma + 0.5) # radius as in ndimage + win_size = 2 * r + 1 + nch = 3 + + weight = torch.Tensor([-(x - win_size//2)**2/float(2*sigma**2) for x in range(win_size)]).exp().unsqueeze(1) + weight = weight.mm(weight.t()) + weight /= weight.sum() + weight = weight.repeat(nch, 1, 1, 1) + + return weight + + self.weight = _get_ssim_weight().to(self.device_type, dtype=self.dtype, non_blocking=True) + + def forward(self, im1, im2, data_range=None): + """Implementation adopted from skimage.metrics.structural_similarity + Default arguments set to multichannel=True, gaussian_weight=True, use_sample_covariance=False + """ + + im1 = im1.to(self.device_type, dtype=self.dtype, non_blocking=True) + im2 = im2.to(self.device_type, dtype=self.dtype, non_blocking=True) + + K1 = 0.01 + K2 = 0.03 + sigma = 1.5 + + truncate = 3.5 + r = int(truncate * sigma + 0.5) # radius as in ndimage + win_size = 2 * r + 1 + + im1 = _expand(im1) + im2 = _expand(im2) + + nch = im1.shape[1] + + if im1.shape[2] < win_size or im1.shape[3] < win_size: + raise ValueError( + "win_size exceeds image extent. If the input is a multichannel " + "(color) image, set multichannel=True.") + + if data_range is None: + data_range = 255 if im1.max() > 1 else 1 + + def filter_func(img): # no padding + return nn.functional.conv2d(img, self.weight, groups=nch).to(self.dtype) + # return torch.conv2d(img, self.weight, groups=nch).to(self.dtype) + + # compute (weighted) means + ux = filter_func(im1) + uy = filter_func(im2) + + # compute (weighted) variances and covariances + uxx = filter_func(im1 * im1) + uyy = filter_func(im2 * im2) + uxy = filter_func(im1 * im2) + vx = (uxx - ux * ux) + vy = (uyy - uy * uy) + vxy = (uxy - ux * uy) + + R = data_range + C1 = (K1 * R) ** 2 + C2 = (K2 * R) ** 2 + + A1, A2, B1, B2 = ((2 * ux * uy + C1, + 2 * vxy + C2, + ux ** 2 + uy ** 2 + C1, + vx + vy + C2)) + D = B1 * B2 + S = (A1 * A2) / D + + # compute (weighted) mean of ssim + mssim = S.mean() + + return mssim diff --git a/backup/deblur/src/main.py b/backup/deblur/src/main.py new file mode 100644 index 0000000000000000000000000000000000000000..744004383066e9444d5accf9698fc9a55ed25515 --- /dev/null +++ b/backup/deblur/src/main.py @@ -0,0 +1,67 @@ +"""main file that does everything""" +from utils import interact + +from option import args, setup, cleanup +from data import Data +from model import Model +from loss import Loss +from optim import Optimizer +from train import Trainer + +def main_worker(rank, args): + args.rank = rank + args = setup(args) + + loaders = Data(args).get_loader() + model = Model(args) + model.parallelize() + optimizer = Optimizer(args, model) + + criterion = Loss(args, model=model, optimizer=optimizer) + + trainer = Trainer(args, model, criterion, optimizer, loaders) + + if args.stay: + interact(local=locals()) + exit() + + if args.demo: + trainer.evaluate(epoch=args.start_epoch, mode='demo') + exit() + + for epoch in range(1, args.start_epoch): + if args.do_validate: + if epoch % args.validate_every == 0: + trainer.fill_evaluation(epoch, 'val') + if args.do_test: + if epoch % args.test_every == 0: + trainer.fill_evaluation(epoch, 'test') + + for epoch in range(args.start_epoch, args.end_epoch+1): + if args.do_train: + trainer.train(epoch) + + if args.do_validate: + if epoch % args.validate_every == 0: + if trainer.epoch != epoch: + trainer.load(epoch) + trainer.validate(epoch) + + if args.do_test: + if epoch % args.test_every == 0: + if trainer.epoch != epoch: + trainer.load(epoch) + trainer.test(epoch) + + if args.rank == 0 or not args.launched: + print('') + + trainer.imsaver.join_background() + + cleanup(args) + +def main(): + main_worker(args.rank, args) + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/backup/deblur/src/model/LamResNet.py b/backup/deblur/src/model/LamResNet.py new file mode 100644 index 0000000000000000000000000000000000000000..4d5f3f396d5b1534e929e3770bee6d38babd93be --- /dev/null +++ b/backup/deblur/src/model/LamResNet.py @@ -0,0 +1,72 @@ +import torch.nn as nn + +from . import common + +from lambda_networks import LambdaLayer + + +def build_model(args): + return ResNet(args) + + +class ResNet(nn.Module): + def __init__( + self, + args, + in_channels=3, + out_channels=3, + n_feats=None, + kernel_size=None, + n_resblocks=None, + mean_shift=True, + ): + super(ResNet, self).__init__() + + self.in_channels = in_channels + self.out_channels = out_channels + + self.n_feats = args.n_feats if n_feats is None else n_feats + self.kernel_size = args.kernel_size if kernel_size is None else kernel_size + self.n_resblocks = args.n_resblocks if n_resblocks is None else n_resblocks + + self.mean_shift = mean_shift + self.rgb_range = args.rgb_range + self.mean = self.rgb_range / 2 + + modules = [] + modules.append( + common.default_conv(self.in_channels, self.n_feats, self.kernel_size) + ) + for _ in range(self.n_resblocks // 3): + modules.append(common.ResBlock(self.n_feats, self.kernel_size)) + modules.append( + LambdaLayer( + dim=self.n_feats, dim_out=self.n_feats, r=23, dim_k=16, heads=4, dim_u=1 + ) + ) + for _ in range(self.n_resblocks // 3): + modules.append(common.ResBlock(self.n_feats, self.kernel_size)) + modules.append( + LambdaLayer( + dim=self.n_feats, dim_out=self.n_feats, r=7, dim_k=16, heads=4, dim_u=4 + ) + ) + for _ in range(self.n_resblocks // 3): + modules.append(common.ResBlock(self.n_feats, self.kernel_size)) + modules.append( + common.default_conv(self.n_feats, self.n_feats, self.kernel_size) + ) + modules.append(common.default_conv(self.n_feats, self.out_channels, 1)) + + self.body = nn.Sequential(*modules) + + def forward(self, input): + if self.mean_shift: + input = input - self.mean + + output = self.body(input) + + if self.mean_shift: + output = output + self.mean + + return output diff --git a/backup/deblur/src/model/MSResNet.py b/backup/deblur/src/model/MSResNet.py new file mode 100644 index 0000000000000000000000000000000000000000..7aae5e553fa093760061e4197661ed44cacefc3c --- /dev/null +++ b/backup/deblur/src/model/MSResNet.py @@ -0,0 +1,67 @@ +import torch +import torch.nn as nn + +from . import common +from .ResNet import ResNet + + +def build_model(args): + return MSResNet(args) + +class conv_end(nn.Module): + def __init__(self, in_channels=3, out_channels=3, kernel_size=5, ratio=2): + super(conv_end, self).__init__() + + modules = [ + common.default_conv(in_channels, out_channels, kernel_size), + nn.PixelShuffle(ratio) + ] + + self.uppath = nn.Sequential(*modules) + + def forward(self, x): + return self.uppath(x) + +class MSResNet(nn.Module): + def __init__(self, args): + super(MSResNet, self).__init__() + + self.rgb_range = args.rgb_range + self.mean = self.rgb_range / 2 + + self.n_resblocks = args.n_resblocks + self.n_feats = args.n_feats + self.kernel_size = args.kernel_size + + self.n_scales = args.n_scales + + self.body_models = nn.ModuleList([ + ResNet(args, 3, 3, mean_shift=False), + ]) + for _ in range(1, self.n_scales): + self.body_models.insert(0, ResNet(args, 6, 3, mean_shift=False)) + + self.conv_end_models = nn.ModuleList([None]) + for _ in range(1, self.n_scales): + self.conv_end_models += [conv_end(3, 12)] + + def forward(self, input_pyramid): + + scales = range(self.n_scales-1, -1, -1) # 0: fine, 2: coarse + + for s in scales: + input_pyramid[s] = input_pyramid[s] - self.mean + + output_pyramid = [None] * self.n_scales + + input_s = input_pyramid[-1] + for s in scales: # [2, 1, 0] + output_pyramid[s] = self.body_models[s](input_s) + if s > 0: + up_feat = self.conv_end_models[s](output_pyramid[s]) + input_s = torch.cat((input_pyramid[s-1], up_feat), 1) + + for s in scales: + output_pyramid[s] = output_pyramid[s] + self.mean + + return output_pyramid diff --git a/backup/deblur/src/model/MSResNetLambda.py b/backup/deblur/src/model/MSResNetLambda.py new file mode 100644 index 0000000000000000000000000000000000000000..c9c63b895678d5423722389c79fa89d3755a6a2a --- /dev/null +++ b/backup/deblur/src/model/MSResNetLambda.py @@ -0,0 +1,77 @@ +import torch +import torch.nn as nn + +from . import common +from .ResNet import ResNet +from lambda_network import LambdaLayer + +def build_model(args): + return MSResNet(args) + +class conv_end(nn.Module): + def __init__(self, in_channels=3, out_channels=3, kernel_size=5, ratio=2): + super(conv_end, self).__init__() + + modules = [ + common.default_conv(in_channels, out_channels, kernel_size), + nn.PixelShuffle(ratio) + ] + + self.uppath = nn.Sequential(*modules) + + def forward(self, x): + return self.uppath(x) + +class MSResNet(nn.Module): + def __init__(self, args): + super(MSResNet, self).__init__() + + self.rgb_range = args.rgb_range + self.mean = self.rgb_range / 2 + + self.n_resblocks = args.n_resblocks + self.n_feats = args.n_feats + self.kernel_size = args.kernel_size + + self.n_scales = args.n_scales + + self.body_models = nn.ModuleList([ + ResNet(args, 3, 3, mean_shift=False), + ]) + self.lambda_models = nn.ModuleList([ + LambdaLayer( + dim = 32, # channels going in + dim_out = 32, # channels out + n = 64 * 64, # number of input pixels (64 x 64 image) + dim_k = 16, # key dimension + heads = 4, # number of heads, for multi-query + dim_u = 1 # 'intra-depth' dimension +) + ]) + for _ in range(1, self.n_scales): + self.body_models.insert(0, ResNet(args, 6, 3, mean_shift=False)) + + self.conv_end_models = nn.ModuleList([None]) + for _ in range(1, self.n_scales): + self.conv_end_models += [conv_end(3, 12)] + + def forward(self, input_pyramid): + + scales = range(self.n_scales-1, -1, -1) # 0: fine, 2: coarse + + for s in scales: + input_pyramid[s] = input_pyramid[s] - self.mean + + output_pyramid = [None] * self.n_scales + + input_s = input_pyramid[-1] + for s in scales: # [2, 1, 0] + output_pyramid[s] = self.body_models[s](input_s) + if s > 0: + up_feat = self.conv_end_models[s](output_pyramid[s]) + input_s = torch.cat((input_pyramid[s-1], up_feat), 1) + + for s in scales: + output_pyramid[s] = output_pyramid[s] + self.mean + + return output_pyramid diff --git a/backup/deblur/src/model/RaftNet.py b/backup/deblur/src/model/RaftNet.py new file mode 100644 index 0000000000000000000000000000000000000000..cb831aba6f85913df969c9d4bae6869143183df4 --- /dev/null +++ b/backup/deblur/src/model/RaftNet.py @@ -0,0 +1,118 @@ +import torch.nn as nn + +import torch +from . import common + +from lambda_networks import LambdaLayer + + +def build_model(args): + return ResNet(args) + + +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 + + +class ResNet(nn.Module): + def __init__( + self, + args + ): + super(ResNet, self).__init__() + + self.in_channels = 3 + self.out_channels = 3 + + self.rgb_range = args.rgb_range + self.mean = self.rgb_range / 2 + + self.n_feats = args.n_feats + self.kernel_size = args.kernel_size + self.n_resblocks = args.n_resblocks + + self.recurrence = args.n_scales + + modules = [] + m_head=[common.default_conv(self.in_channels, self.n_feats, self.kernel_size)] + for i in range(3): + m_head.append(common.ResBlock(self.n_feats, self.kernel_size)) + for _ in range(self.n_resblocks // 2): + modules.append(common.ResBlock(self.n_feats, self.kernel_size)) + modules.append( + LambdaLayer( + dim=self.n_feats, dim_out=self.n_feats, r=23, dim_k=16, heads=4, dim_u=4 + ) + ) + for _ in range(self.n_resblocks // 2): + modules.append(common.ResBlock(self.n_feats, self.kernel_size)) + m_tail=[] + + for i in range(3): + m_tail.append(common.ResBlock(self.n_feats, self.kernel_size)) + + m_tail.append( + common.default_conv(self.n_feats, self.out_channels, self.kernel_size) + ) + self.head=nn.Sequential(*m_head) + self.body = nn.Sequential(*modules) + self.tail=nn.Sequential(*m_tail) + self.gru=SepConvGRU(hidden_dim=self.n_feats,input_dim=self.n_feats) + + def forward(self, input): + input = input[0] - self.mean + input=self.head(input) + hidden=input.clone() + output_lst=[None]*self.recurrence + for i in range(self.recurrence): + gru_out=self.gru(hidden,input) + res=self.body(gru_out) + gru_out=res+gru_out + hidden=gru_out + tail_out=self.tail(gru_out) + output_lst[i] = self.tail(gru_out) + self.mean + return output_lst diff --git a/backup/deblur/src/model/RaftNets.py b/backup/deblur/src/model/RaftNets.py new file mode 100644 index 0000000000000000000000000000000000000000..b67b6eb2c1ee40b86e87dbeaca00e97d1c87e3ba --- /dev/null +++ b/backup/deblur/src/model/RaftNets.py @@ -0,0 +1,119 @@ +import torch.nn as nn + +import torch +from . import common + +from lambda_networks import LambdaLayer + + +def build_model(args): + return ResNet(args) + + +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 + + +class ResNet(nn.Module): + def __init__( + self, + args + ): + super(ResNet, self).__init__() + + self.in_channels = 3 + self.out_channels = 3 + + self.rgb_range = args.rgb_range + self.mean = self.rgb_range / 2 + + self.n_feats = args.n_feats + self.kernel_size = args.kernel_size + self.n_resblocks = args.n_resblocks + + self.recurrence = args.n_scales + + modules = [] + m_head=[common.default_conv(self.in_channels, self.n_feats, self.kernel_size)] + for i in range(2): + m_head.append(common.ResBlock(self.n_feats, self.kernel_size)) + for _ in range(self.n_resblocks // 2): + modules.append(common.ResBlock(self.n_feats, self.kernel_size)) + modules.append( + LambdaLayer( + dim=self.n_feats, dim_out=self.n_feats, r=23, dim_k=16, heads=4, dim_u=4 + ) + ) + for _ in range(self.n_resblocks // 2): + modules.append(common.ResBlock(self.n_feats, self.kernel_size)) + m_tail=[] + + for i in range(2): + m_tail.append(common.ResBlock(self.n_feats, self.kernel_size)) + + m_tail.append( + common.default_conv(self.n_feats, self.out_channels, self.kernel_size) + ) + self.head=nn.Sequential(*m_head) + self.hidden_encoder=nn.Sequential(common.ResBlock(self.n_feats, self.kernel_size),common.ResBlock(self.n_feats, self.kernel_size),common.ResBlock(self.n_feats, self.kernel_size)) + self.body = nn.Sequential(*modules) + self.tail=nn.Sequential(*m_tail) + self.gru=SepConvGRU(hidden_dim=self.n_feats,input_dim=self.n_feats) + + def forward(self, input): + input = input[0] - self.mean + input=self.head(input) + hidden=self.hidden_encoder(input) + output_lst=[None]*self.recurrence + for i in range(self.recurrence): + gru_out=self.gru(hidden,input.detach()) + res=self.body(gru_out) + gru_out=res+gru_out + hidden=gru_out + tail_out=self.tail(gru_out) + output_lst[i] = self.tail(gru_out) + self.mean + return output_lst diff --git a/backup/deblur/src/model/RecLamResNet.py b/backup/deblur/src/model/RecLamResNet.py new file mode 100644 index 0000000000000000000000000000000000000000..7aaf39af6cb858b9f092a03ff002990c44ba55da --- /dev/null +++ b/backup/deblur/src/model/RecLamResNet.py @@ -0,0 +1,54 @@ +import torch +import torch.nn as nn + +from . import common +from .LamResNet import ResNet + + +def build_model(args): + return RecLamResNet(args) + + +class conv_end(nn.Module): + def __init__(self, in_channels=3, out_channels=3, kernel_size=5, ratio=2): + super(conv_end, self).__init__() + + modules = [ + common.default_conv(in_channels, out_channels, kernel_size), + nn.PixelShuffle(ratio), + ] + + self.uppath = nn.Sequential(*modules) + + def forward(self, x): + return self.uppath(x) + + +class RecLamResNet(nn.Module): + def __init__(self, args): + super(RecLamResNet, self).__init__() + + self.rgb_range = args.rgb_range + self.mean = self.rgb_range / 2 + self.is_detach=args.detach + + self.n_resblocks = args.n_resblocks + self.n_feats = args.n_feats + self.kernel_size = args.kernel_size + + self.n_scales = args.n_scales + + self.body_model = ResNet(args, 3, 3, mean_shift=False) + + def forward(self, input_lst): + # we use a reversed list for better compact + input_lst[0] = input_lst[0] - self.mean + output_lst = [None] * self.n_scales + last_output = input_lst[0] + for i in range(self.n_scales): + if self.is_detach: + last_output=last_output.detach() + output = self.body_model(last_output) + last_output + output_lst[self.n_scales-i-1] = output + self.mean + last_output = output + return output_lst diff --git a/backup/deblur/src/model/ResNet.py b/backup/deblur/src/model/ResNet.py new file mode 100644 index 0000000000000000000000000000000000000000..99c97033a354a564f28319ef4e5cebc8d5680af7 --- /dev/null +++ b/backup/deblur/src/model/ResNet.py @@ -0,0 +1,41 @@ +import torch.nn as nn + +from . import common + +def build_model(args): + return ResNet(args) + +class ResNet(nn.Module): + def __init__(self, args, in_channels=3, out_channels=3, n_feats=None, kernel_size=None, n_resblocks=None, mean_shift=True): + super(ResNet, self).__init__() + + self.in_channels = in_channels + self.out_channels = out_channels + + self.n_feats = args.n_feats if n_feats is None else n_feats + self.kernel_size = args.kernel_size if kernel_size is None else kernel_size + self.n_resblocks = args.n_resblocks if n_resblocks is None else n_resblocks + + self.mean_shift = mean_shift + self.rgb_range = args.rgb_range + self.mean = self.rgb_range / 2 + + modules = [] + modules.append(common.default_conv(self.in_channels, self.n_feats, self.kernel_size)) + for _ in range(self.n_resblocks): + modules.append(common.ResBlock(self.n_feats, self.kernel_size)) + modules.append(common.default_conv(self.n_feats, self.out_channels, self.kernel_size)) + + self.body = nn.Sequential(*modules) + + def forward(self, input): + if self.mean_shift: + input = input - self.mean + + output = self.body(input) + + if self.mean_shift: + output = output + self.mean + + return output + diff --git a/backup/deblur/src/model/__init__.py b/backup/deblur/src/model/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f6d402da3b5c34ee239034006e85d0269a8c911b --- /dev/null +++ b/backup/deblur/src/model/__init__.py @@ -0,0 +1,136 @@ +import os +import re +from importlib import import_module + +import torch +import torch.nn as nn +from torch.nn.parallel import DataParallel, DistributedDataParallel + +import torch.distributed as dist +from torch.nn.utils import parameters_to_vector, vector_to_parameters + +from .discriminator import Discriminator + +from utils import interact + +class Model(nn.Module): + def __init__(self, args): + super(Model, self).__init__() + + self.args = args + self.device = args.device + self.n_GPUs = args.n_GPUs + self.save_dir = os.path.join(args.save_dir, 'models') + os.makedirs(self.save_dir, exist_ok=True) + + module = import_module('model.' + args.model) + + self.model = nn.ModuleDict() + self.model.G = module.build_model(args) + if self.args.loss.lower().find('adv') >= 0: + self.model.D = Discriminator(self.args) + else: + self.model.D = None + + self.to(args.device, dtype=args.dtype, non_blocking=True) + self.load(args.load_epoch, path=args.pretrained) + + def parallelize(self): + if self.args.device_type == 'cuda': + if self.args.distributed: + Parallel = DistributedDataParallel + parallel_args = { + "device_ids": [self.args.rank], + "output_device": self.args.rank, + } + else: + Parallel = DataParallel + parallel_args = { + 'device_ids': list(range(self.n_GPUs)), + 'output_device': self.args.rank # always 0 + } + + for model_key in self.model: + if self.model[model_key] is not None: + self.model[model_key] = Parallel(self.model[model_key], **parallel_args) + + def forward(self, input): + return self.model.G(input) + + def _save_path(self, epoch): + model_path = os.path.join(self.save_dir, 'model-{:d}.pt'.format(epoch)) + return model_path + + def state_dict(self): + state_dict = {} + for model_key in self.model: + if self.model[model_key] is not None: + parallelized = isinstance(self.model[model_key], (DataParallel, DistributedDataParallel)) + if parallelized: + state_dict[model_key] = self.model[model_key].module.state_dict() + else: + state_dict[model_key] = self.model[model_key].state_dict() + + return state_dict + + def load_state_dict(self, state_dict, strict=True): + for model_key in self.model: + parallelized = isinstance(self.model[model_key], (DataParallel, DistributedDataParallel)) + if model_key in state_dict: + if parallelized: + self.model[model_key].module.load_state_dict(state_dict[model_key], strict) + else: + self.model[model_key].load_state_dict(state_dict[model_key], strict) + + def save(self, epoch): + torch.save(self.state_dict(), self._save_path(epoch)) + + def load(self, epoch=None, path=None): + if path: + model_name = path + elif isinstance(epoch, int): + if epoch < 0: + epoch = self.get_last_epoch() + if epoch == 0: # epoch 0 + # make sure model parameters are synchronized at initial + # for multi-node training (not in current implementation) + # self.synchronize() + + return # leave model as initialized + + model_name = self._save_path(epoch) + else: + raise Exception('no epoch number or model path specified!') + + print('Loading model from {}'.format(model_name)) + state_dict = torch.load(model_name, map_location=self.args.device) + self.load_state_dict(state_dict) + + return + + def synchronize(self): + if self.args.distributed: + # synchronize model parameters across nodes + vector = parameters_to_vector(self.parameters()) + + dist.broadcast(vector, 0) # broadcast parameters to other processes + if self.args.rank != 0: + vector_to_parameters(vector, self.parameters()) + + del vector + + return + + def get_last_epoch(self): + model_list = sorted(os.listdir(self.save_dir)) + if len(model_list) == 0: + epoch = 0 + else: + epoch = int(re.findall('\\d+', model_list[-1])[0]) # model example name model-100.pt + + return epoch + + def print(self): + print(self.model) + + return diff --git a/backup/deblur/src/model/__pycache__/LamResNet.cpython-37.pyc b/backup/deblur/src/model/__pycache__/LamResNet.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..34faaaff7d304814ce6ba3a213cd5ecbac867d47 Binary files /dev/null and b/backup/deblur/src/model/__pycache__/LamResNet.cpython-37.pyc differ diff --git a/backup/deblur/src/model/__pycache__/RaftNet.cpython-37.pyc b/backup/deblur/src/model/__pycache__/RaftNet.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bb595498c1dd1b152c3b4a479842a946e0360614 Binary files /dev/null and b/backup/deblur/src/model/__pycache__/RaftNet.cpython-37.pyc differ diff --git a/backup/deblur/src/model/__pycache__/RaftNets.cpython-37.pyc b/backup/deblur/src/model/__pycache__/RaftNets.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b5a525212e85f90e3d27500fd1859517f0c339de Binary files /dev/null and b/backup/deblur/src/model/__pycache__/RaftNets.cpython-37.pyc differ diff --git a/backup/deblur/src/model/__pycache__/RecLamResNet.cpython-37.pyc b/backup/deblur/src/model/__pycache__/RecLamResNet.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7ebfd4aebfa592fff9a196301f92d63b34d34fb6 Binary files /dev/null and b/backup/deblur/src/model/__pycache__/RecLamResNet.cpython-37.pyc differ diff --git a/backup/deblur/src/model/__pycache__/__init__.cpython-37.pyc b/backup/deblur/src/model/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..54da89d75734d131e9531091c0e7ce798d839c5f Binary files /dev/null and b/backup/deblur/src/model/__pycache__/__init__.cpython-37.pyc differ diff --git a/backup/deblur/src/model/__pycache__/common.cpython-37.pyc b/backup/deblur/src/model/__pycache__/common.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fc1093146590882e1ec67b8e1101556fb736f558 Binary files /dev/null and b/backup/deblur/src/model/__pycache__/common.cpython-37.pyc differ diff --git a/backup/deblur/src/model/__pycache__/discriminator.cpython-37.pyc b/backup/deblur/src/model/__pycache__/discriminator.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..515e3b914c11e0f0561d084d607d1698ae871dff Binary files /dev/null and b/backup/deblur/src/model/__pycache__/discriminator.cpython-37.pyc differ diff --git a/backup/deblur/src/model/common.py b/backup/deblur/src/model/common.py new file mode 100644 index 0000000000000000000000000000000000000000..43c87f347aae745794e514988fb0e2e3330a1d95 --- /dev/null +++ b/backup/deblur/src/model/common.py @@ -0,0 +1,161 @@ +import math + +import torch +import torch.nn as nn + +def default_conv(in_channels, out_channels, kernel_size, bias=True, groups=1): + return nn.Conv2d( + in_channels, out_channels, kernel_size, + padding=(kernel_size // 2), bias=bias, groups=groups) + +def default_norm(n_feats): + return nn.BatchNorm2d(n_feats) + +def default_act(): + return nn.ReLU(True) + +def empty_h(x, n_feats): + ''' + create an empty hidden state + + input + x: B x T x 3 x H x W + + output + h: B x C x H/4 x W/4 + ''' + b = x.size(0) + h, w = x.size()[-2:] + return x.new_zeros((b, n_feats, h//4, w//4)) + +class Normalization(nn.Conv2d): + """Normalize input tensor value with convolutional layer""" + def __init__(self, mean=(0, 0, 0), std=(1, 1, 1)): + super(Normalization, self).__init__(3, 3, kernel_size=1) + tensor_mean = torch.Tensor(mean) + tensor_inv_std = torch.Tensor(std).reciprocal() + + self.weight.data = torch.eye(3).mul(tensor_inv_std).view(3, 3, 1, 1) + self.bias.data = torch.Tensor(-tensor_mean.mul(tensor_inv_std)) + + for params in self.parameters(): + params.requires_grad = False + +class BasicBlock(nn.Sequential): + """Convolution layer + Activation layer""" + def __init__( + self, in_channels, out_channels, kernel_size, bias=True, + conv=default_conv, norm=False, act=default_act): + + modules = [] + modules.append( + conv(in_channels, out_channels, kernel_size, bias=bias)) + if norm: modules.append(norm(out_channels)) + if act: modules.append(act()) + + super(BasicBlock, self).__init__(*modules) + +class ResBlock(nn.Module): + def __init__( + self, n_feats, kernel_size, bias=True, + conv=default_conv, norm=False, act=default_act): + + super(ResBlock, self).__init__() + + modules = [] + for i in range(2): + modules.append(conv(n_feats, n_feats, kernel_size, bias=bias)) + if norm: modules.append(norm(n_feats)) + if act and i == 0: modules.append(act()) + + self.body = nn.Sequential(*modules) + + def forward(self, x): + res = self.body(x) + res += x + + return res + +class ResBlock_mobile(nn.Module): + def __init__( + self, n_feats, kernel_size, bias=True, + conv=default_conv, norm=False, act=default_act, dropout=False): + + super(ResBlock_mobile, self).__init__() + + modules = [] + for i in range(2): + modules.append(conv(n_feats, n_feats, kernel_size, bias=False, groups=n_feats)) + modules.append(conv(n_feats, n_feats, 1, bias=False)) + if dropout and i == 0: modules.append(nn.Dropout2d(dropout)) + if norm: modules.append(norm(n_feats)) + if act and i == 0: modules.append(act()) + + self.body = nn.Sequential(*modules) + + def forward(self, x): + res = self.body(x) + res += x + + return res + +class Upsampler(nn.Sequential): + def __init__( + self, scale, n_feats, bias=True, + conv=default_conv, norm=False, act=False): + + modules = [] + if (scale & (scale - 1)) == 0: # Is scale = 2^n? + for _ in range(int(math.log(scale, 2))): + modules.append(conv(n_feats, 4 * n_feats, 3, bias)) + modules.append(nn.PixelShuffle(2)) + if norm: modules.append(norm(n_feats)) + if act: modules.append(act()) + elif scale == 3: + modules.append(conv(n_feats, 9 * n_feats, 3, bias)) + modules.append(nn.PixelShuffle(3)) + if norm: modules.append(norm(n_feats)) + if act: modules.append(act()) + else: + raise NotImplementedError + + super(Upsampler, self).__init__(*modules) + +# Only support 1 / 2 +class PixelSort(nn.Module): + """The inverse operation of PixelShuffle + Reduces the spatial resolution, increasing the number of channels. + Currently, scale 0.5 is supported only. + Later, torch.nn.functional.pixel_sort may be implemented. + Reference: + http://pytorch.org/docs/0.3.0/_modules/torch/nn/modules/pixelshuffle.html#PixelShuffle + http://pytorch.org/docs/0.3.0/_modules/torch/nn/functional.html#pixel_shuffle + """ + def __init__(self, upscale_factor=0.5): + super(PixelSort, self).__init__() + self.upscale_factor = upscale_factor + + def forward(self, x): + b, c, h, w = x.size() + x = x.view(b, c, 2, 2, h // 2, w // 2) + x = x.permute(0, 1, 5, 3, 2, 4).contiguous() + x = x.view(b, 4 * c, h // 2, w // 2) + + return x + +class Downsampler(nn.Sequential): + def __init__( + self, scale, n_feats, bias=True, + conv=default_conv, norm=False, act=False): + + modules = [] + if scale == 0.5: + modules.append(PixelSort()) + modules.append(conv(4 * n_feats, n_feats, 3, bias)) + if norm: modules.append(norm(n_feats)) + if act: modules.append(act()) + else: + raise NotImplementedError + + super(Downsampler, self).__init__(*modules) + diff --git a/backup/deblur/src/model/discriminator.py b/backup/deblur/src/model/discriminator.py new file mode 100644 index 0000000000000000000000000000000000000000..593cddc8af493efbc1d6e474e078318788bbf543 --- /dev/null +++ b/backup/deblur/src/model/discriminator.py @@ -0,0 +1,41 @@ +import torch.nn as nn + +class Discriminator(nn.Module): + def __init__(self, args): + super(Discriminator, self).__init__() + + # self.args = args + n_feats = args.n_feats + kernel_size = args.kernel_size + + def conv(kernel_size, in_channel, n_feats, stride, pad=None): + if pad is None: + pad = (kernel_size-1)//2 + + return nn.Conv2d(in_channel, n_feats, kernel_size, stride=stride, padding=pad, bias=False) + + self.conv_layers = nn.ModuleList([ + conv(kernel_size, 3, n_feats//2, 1), # 256 + conv(kernel_size, n_feats//2, n_feats//2, 2), # 128 + conv(kernel_size, n_feats//2, n_feats, 1), + conv(kernel_size, n_feats, n_feats, 2), # 64 + conv(kernel_size, n_feats, n_feats*2, 1), + conv(kernel_size, n_feats*2, n_feats*2, 4), # 16 + conv(kernel_size, n_feats*2, n_feats*4, 1), + conv(kernel_size, n_feats*4, n_feats*4, 4), # 4 + conv(kernel_size, n_feats*4, n_feats*8, 1), + conv(4, n_feats*8, n_feats*8, 4, 0), # 1 + ]) + + self.act = nn.LeakyReLU(negative_slope=0.2, inplace=True) + self.dense = nn.Conv2d(n_feats*8, 1, 1, bias=False) + + def forward(self, x): + + for layer in self.conv_layers: + x = self.act(layer(x)) + + x = self.dense(x) + + return x + diff --git a/backup/deblur/src/model/structure.py b/backup/deblur/src/model/structure.py new file mode 100644 index 0000000000000000000000000000000000000000..8b5b39fe06be7a26601d3e9e690dfb86141b5f1f --- /dev/null +++ b/backup/deblur/src/model/structure.py @@ -0,0 +1,56 @@ +import torch.nn as nn + +from .common import ResBlock, default_conv + +def encoder(in_channels, n_feats): + """RGB / IR feature encoder + """ + + # in_channels == 1 or 3 or 4 or .... + # After 1st conv, B x n_feats x H x W + # After 2nd conv, B x 2n_feats x H/2 x W/2 + # After 3rd conv, B x 3n_feats x H/4 x W/4 + return nn.Sequential( + nn.Conv2d(in_channels, 1 * n_feats, 5, stride=1, padding=2), + nn.Conv2d(1 * n_feats, 2 * n_feats, 5, stride=2, padding=2), + nn.Conv2d(2 * n_feats, 3 * n_feats, 5, stride=2, padding=2), + ) + +def decoder(out_channels, n_feats): + """RGB / IR / Depth decoder + """ + # After 1st deconv, B x 2n_feats x H/2 x W/2 + # After 2nd deconv, B x n_feats x H x W + # After 3rd conv, B x out_channels x H x W + deconv_kargs = {'stride': 2, 'padding': 1, 'output_padding': 1} + + return nn.Sequential( + nn.ConvTranspose2d(3 * n_feats, 2 * n_feats, 3, **deconv_kargs), + nn.ConvTranspose2d(2 * n_feats, 1 * n_feats, 3, **deconv_kargs), + nn.Conv2d(n_feats, out_channels, 5, stride=1, padding=2), + ) + +# def ResNet(n_feats, in_channels=None, out_channels=None): +def ResNet(n_feats, kernel_size, n_blocks, in_channels=None, out_channels=None): + """sequential ResNet + """ + + # if in_channels is None: + # in_channels = n_feats + # if out_channels is None: + # out_channels = n_feats + # # currently not implemented + + m = [] + + if in_channels is not None: + m += [default_conv(in_channels, n_feats, kernel_size)] + + m += [ResBlock(n_feats, 3)] * n_blocks + + if out_channels is not None: + m += [default_conv(n_feats, out_channels, kernel_size)] + + + return nn.Sequential(*m) + diff --git a/backup/deblur/src/nohup.out b/backup/deblur/src/nohup.out new file mode 100644 index 0000000000000000000000000000000000000000..219e2330efefc36ee26af98a6c187fb4c75aaa4d --- /dev/null +++ b/backup/deblur/src/nohup.out @@ -0,0 +1,110 @@ +Workplace: /research/dept7/liuhy/lambda/backup/deblur/src +Traceback (most recent call last): + File "launch.py", line 9, in + from utils import str2bool, int2str + File "/research/dept7/liuhy/lambda/backup/deblur/src/utils.py", line 10, in + import imageio +ImportError: No module named imageio +Workplace: /research/dept7/liuhy/lambda/backup/deblur/src +===> Loading train dataset: GOPRO_Large +===> Loading test dataset: GOPRO_Large +Loss function: 1*MSE +Metrics: PSNR,SSIM +===> Initializing trainer +results are saved in ../experiment/RAFTNET_MSE_R5_rtx/result + | | 0/263 [00:00 Loading train dataset: GOPRO_Large +===> Loading test dataset: GOPRO_Large +Loss function: 1*MSE +Metrics: PSNR,SSIM +===> Initializing trainer +results are saved in ../experiment/RAFTNET_MSE_R5_rtx/result +[Epoch 1 / lr 1.00e-04] + Train Loss: 3666.3: | | 0/263 [00:44 1: + epoch = self.scheduler.last_epoch + else: + epoch = self.args.start_epoch - 1 + + # if False: + # # option 1. new scheduler + # for i, group in enumerate(self.param_groups): + # self.param_groups[i]['lr'] = group['initial_lr'] # reset optimizer learning rate to initial + # # self.scheduler = None + # self._register_scheduler(scheduler_class, kwargs_scheduler) + + # self.zero_grad() + # self.step() + # for _ in range(epoch): + # self.scheduler.step() + # self._step_count -= 1 + + # else: + # option 2. modify existing scheduler + self.scheduler.milestones = Counter(self.args.milestones) + self.scheduler.gamma = self.args.gamma + for i, group in enumerate(self.param_groups): + self.param_groups[i]['lr'] = group['initial_lr'] # reset optimizer learning rate to initial + multiplier = 1 + for milestone in self.scheduler.milestones: + if epoch >= milestone: + multiplier *= self.scheduler.gamma + + self.param_groups[i]['lr'] *= multiplier + + return _Optimizer(model, args, scheduler_class, kwargs_scheduler) + + self.G = _get_optimizer(model.G) + if model.D is not None: + self.D = _get_optimizer(model.D) + else: + self.D = None + + self.load(args.load_epoch) + + def zero_grad(self): + self.G.zero_grad() + + def step(self): + self.G.step() + + def schedule(self, metrics=None): + self.G.schedule(metrics) + if self.D is not None: + self.D.schedule(metrics) + + def get_last_epoch(self): + return self.G.get_last_epoch() + + def get_lr(self): + return self.G.get_lr() + + def get_last_lr(self): + return self.G.get_last_lr() + + def state_dict(self): + state_dict = Map() + state_dict.G = self.G.state_dict() + if self.D is not None: + state_dict.D = self.D.state_dict() + + return state_dict.toDict() + + def load_state_dict(self, state_dict, epoch=None): + state_dict = Map(**state_dict) + self.G.load_state_dict(state_dict.G, epoch) + if self.D is not None: + self.D.load_state_dict(state_dict.D, epoch) + + def _save_path(self, epoch=None): + epoch = epoch if epoch is not None else self.get_last_epoch() + save_path = os.path.join(self.save_dir, 'optim-{:d}.pt'.format(epoch)) + + return save_path + + def save(self, epoch=None): + if epoch is None: + epoch = self.G.scheduler.last_epoch + torch.save(self.state_dict(), self._save_path(epoch)) + + def load(self, epoch): + if epoch > 0: + print('Loading optimizer from {}'.format(self._save_path(epoch))) + self.load_state_dict(torch.load(self._save_path(epoch), map_location=self.args.device), epoch=epoch) + + elif epoch == 0: + pass + else: + raise NotImplementedError + + return + diff --git a/backup/deblur/src/optim/__pycache__/__init__.cpython-37.pyc b/backup/deblur/src/optim/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0614279fe3f42b27c2c80d874d63860210efd052 Binary files /dev/null and b/backup/deblur/src/optim/__pycache__/__init__.cpython-37.pyc differ diff --git a/backup/deblur/src/optim/warm_multi_step_lr.py b/backup/deblur/src/optim/warm_multi_step_lr.py new file mode 100644 index 0000000000000000000000000000000000000000..ee549653627e34e6020f0c75d8a926f4c842343a --- /dev/null +++ b/backup/deblur/src/optim/warm_multi_step_lr.py @@ -0,0 +1,32 @@ +import math +from bisect import bisect_right +from torch.optim.lr_scheduler import _LRScheduler + +# MultiStep learning rate scheduler with warm restart +class WarmMultiStepLR(_LRScheduler): + def __init__(self, optimizer, milestones, gamma=0.1, last_epoch=-1, scale=1): + if not list(milestones) == sorted(milestones): + raise ValueError( + 'Milestones should be a list of increasing integers. Got {}', + milestones + ) + + self.milestones = milestones + self.gamma = gamma + self.scale = scale + + self.warmup_epochs = 5 + self.gradual = (self.scale - 1) / self.warmup_epochs + super(WarmMultiStepLR, self).__init__(optimizer, last_epoch) + + def get_lr(self): + if self.last_epoch < self.warmup_epochs: + return [ + base_lr * (1 + self.last_epoch * self.gradual) / self.scale + for base_lr in self.base_lrs + ] + else: + return [ + base_lr * self.gamma ** bisect_right(self.milestones, self.last_epoch) + for base_lr in self.base_lrs + ] diff --git a/backup/deblur/src/option.py b/backup/deblur/src/option.py new file mode 100644 index 0000000000000000000000000000000000000000..388dc4ba3e6efc2015be26f8e8bde4d3cbcfdb22 --- /dev/null +++ b/backup/deblur/src/option.py @@ -0,0 +1,278 @@ +"""optionional argument parsing""" +# pylint: disable=C0103, C0301 +import argparse +import datetime +import os +import re +import shutil +import time + +import torch +import torch.distributed as dist +import torch.backends.cudnn as cudnn + +from utils import interact +from utils import str2bool, int2str + +import template + +# Training settings +parser = argparse.ArgumentParser(description='Dynamic Scene Deblurring') + +# Device specifications +group_device = parser.add_argument_group('Device specs') +group_device.add_argument('--seed', type=int, default=-1, help='random seed') +group_device.add_argument('--num_workers', type=int, default=7, help='the number of dataloader workers') +group_device.add_argument('--device_type', type=str, choices=('cpu', 'cuda'), default='cuda', help='device to run models') +group_device.add_argument('--device_index', type=int, default=0, help='device id to run models') +group_device.add_argument('--n_GPUs', type=int, default=1, help='the number of GPUs for training') +group_device.add_argument('--distributed', type=str2bool, default=False, help='use DistributedDataParallel instead of DataParallel for better speed') +group_device.add_argument('--launched', type=str2bool, default=False, help='identify if main.py was executed from launch.py. Do not set this to be true using main.py.') + +group_device.add_argument('--master_addr', type=str, default='127.0.0.1', help='master address for distributed') +group_device.add_argument('--master_port', type=int2str, default='8023', help='master port for distributed') +group_device.add_argument('--dist_backend', type=str, default='nccl', help='distributed backend') +group_device.add_argument('--init_method', type=str, default='env://', help='distributed init method URL to discover peers') +group_device.add_argument('--rank', type=int, default=0, help='rank of the distributed process (gpu id). 0 is the master process.') +group_device.add_argument('--world_size', type=int, default=1, help='world_size for distributed training (number of GPUs)') + +# Data +group_data = parser.add_argument_group('Data specs') +group_data.add_argument('--data_root', type=str, default='/data/ssd/public/czli/deblur', help='dataset root location') +group_data.add_argument('--dataset', type=str, default=None, help='training/validation/test dataset name, has priority if not None') +group_data.add_argument('--data_train', type=str, default='GOPRO_Large', help='training dataset name') +group_data.add_argument('--data_val', type=str, default=None, help='validation dataset name') +group_data.add_argument('--data_test', type=str, default='GOPRO_Large', help='test dataset name') +group_data.add_argument('--blur_key', type=str, default='blur_gamma', choices=('blur', 'blur_gamma'), help='blur type from camera response function for GOPRO_Large dataset') +group_data.add_argument('--rgb_range', type=int, default=255, help='RGB pixel value ranging from 0') + +# Model +group_model = parser.add_argument_group('Model specs') +group_model.add_argument('--model', type=str, default='RecLamResNet', help='model architecture') +group_model.add_argument('--pretrained', type=str, default='', help='pretrained model location') +group_model.add_argument('--n_scales', type=int, default=5, help='multi-scale deblurring level') +group_model.add_argument('--detach', type=str2bool, default=False, help='detach between recurrence') +group_model.add_argument('--gaussian_pyramid', type=str2bool, default=True, help='gaussian pyramid input/target') +group_model.add_argument('--n_resblocks', type=int, default=19, help='number of residual blocks per scale') +group_model.add_argument('--n_feats', type=int, default=64, help='number of feature maps') +group_model.add_argument('--kernel_size', type=int, default=5, help='size of conv kernel') +group_model.add_argument('--downsample', type=str, choices=('Gaussian', 'bicubic', 'stride'), default='Gaussian', help='input pyramid generation method') + +group_model.add_argument('--precision', type=str, default='single', choices=('single', 'half'), help='FP precision for test(single | half)') + +# amp +group_amp = parser.add_argument_group('AMP specs') +group_amp.add_argument('--amp', type=str2bool, default=False, help='use automatic mixed precision training') +group_amp.add_argument('--init_scale', type=float, default=1024., help='initial loss scale') + +# Training +group_train = parser.add_argument_group('Training specs') +group_train.add_argument('--patch_size', type=int, default=256, help='training patch size') +group_train.add_argument('--batch_size', type=int, default=16, help='input batch size for training') +group_train.add_argument('--split_batch', type=int, default=1, help='split a minibatch into smaller chunks') +group_train.add_argument('--augment', type=str2bool, default=True, help='train with data augmentation') + +# Testing +group_test = parser.add_argument_group('Testing specs') +group_test.add_argument('--validate_every', type=int, default=10, help='do validation at every N epochs') +group_test.add_argument('--test_every', type=int, default=10, help='do test at every N epochs') +# group_test.add_argument('--chop', type=str2bool, default=False, help='memory-efficient forward') +# group_test.add_argument('--self_ensemble', type=str2bool, default=False, help='self-ensembled testing') + +# Action +group_action = parser.add_argument_group('Source behavior') +group_action.add_argument('--do_train', type=str2bool, default=True, help='do train the model') +group_action.add_argument('--do_validate', type=str2bool, default=True, help='do validate the model') +group_action.add_argument('--do_test', type=str2bool, default=True, help='do test the model') +group_action.add_argument('--demo', type=str2bool, default=False, help='demo') +group_action.add_argument('--demo_input_dir', type=str, default='', help='demo input directory') +group_action.add_argument('--demo_output_dir', type=str, default='', help='demo output directory') + +# Optimization +group_optim = parser.add_argument_group('Optimization specs') +group_optim.add_argument('--lr', type=float, default=1e-4, help='learning rate') +group_optim.add_argument('--milestones', type=int, nargs='+', default=[500, 750, 900], help='learning rate decay per N epochs') +group_optim.add_argument('--scheduler', default='step', choices=('step', 'plateau'), help='learning rate scheduler type') +group_optim.add_argument('--gamma', type=float, default=0.5, help='learning rate decay factor for step decay') +group_optim.add_argument('--optimizer', default='ADAM', choices=('SGD', 'ADAM', 'RMSprop'), help='optimizer to use (SGD | ADAM | RMSProp)') +group_optim.add_argument('--momentum', type=float, default=0.9, help='SGD momentum') +group_optim.add_argument('--betas', type=float, nargs=2, default=(0.9, 0.999), help='ADAM betas') +group_optim.add_argument('--epsilon', type=float, default=1e-8, help='ADAM epsilon') +group_optim.add_argument('--weight_decay', type=float, default=0, help='weight decay') +group_optim.add_argument('--clip', type=float, default=0, help='weight decay') + +# Loss +group_loss = parser.add_argument_group('Loss specs') +group_loss.add_argument('--loss', type=str, default='1*MSE', help='loss function configuration') +group_loss.add_argument('--metric', type=str, default='PSNR,SSIM', help='metric function configuration. ex) None | PSNR | SSIM | PSNR,SSIM') +group_loss.add_argument('--decay_gamma', type=float, default=0.6, help='gamma decay') + + +# Logging +group_log = parser.add_argument_group('Logging specs') +group_log.add_argument('--save_dir', type=str, default='', help='subdirectory to save experiment logs') +# group_log.add_argument('--load_dir', type=str, default='', help='subdirectory to load experiment logs') +group_log.add_argument('--start_epoch', type=int, default=-1, help='(re)starting epoch number') +group_log.add_argument('--end_epoch', type=int, default=1000, help='ending epoch number') +group_log.add_argument('--load_epoch', type=int, default=-1, help='epoch number to load model (start_epoch-1 for training, start_epoch for testing)') +group_log.add_argument('--save_every', type=int, default=10, help='save model/optimizer at every N epochs') +group_log.add_argument('--save_results', type=str, default='part', choices=('none', 'part', 'all'), help='save none/part/all of result images') + +# Debugging +group_debug = parser.add_argument_group('Debug specs') +group_debug.add_argument('--stay', type=str2bool, default=False, help='stay at interactive console after trainer initialization') + +parser.add_argument('--template', type=str, default='', help='argument template option') + +args = parser.parse_args() +template.set_template(args) + +args.data_root = os.path.expanduser(args.data_root) # recognize home directory +now = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S') +if args.save_dir == '': + args.save_dir = now +args.save_dir = os.path.join('../experiment', args.save_dir) +os.makedirs(args.save_dir, exist_ok=True) + +if args.start_epoch < 0: # start from scratch or continue from the last epoch + # check if there are any models saved before + model_dir = os.path.join(args.save_dir, 'models') + model_prefix = 'model-' + if os.path.exists(model_dir): + model_list = [name for name in os.listdir(model_dir) if name.startswith(model_prefix)] + last_epoch = 0 + for name in model_list: + epochNumber = int(re.findall('\\d+', name)[0]) # model example name model-100.pt + if last_epoch < epochNumber: + last_epoch = epochNumber + + args.start_epoch = last_epoch + 1 + else: + # train from scratch + args.start_epoch = 1 +elif args.start_epoch == 0: + # remove existing directory and start over + if args.rank == 0: # maybe local rank + shutil.rmtree(args.save_dir, ignore_errors=True) + os.makedirs(args.save_dir, exist_ok=True) + args.start_epoch = 1 + +if args.load_epoch < 0: # load_epoch == start_epoch when doing a post-training test for a specific epoch + args.load_epoch = args.start_epoch - 1 + +if args.pretrained: + if args.start_epoch <= 1: + args.pretrained = os.path.join('../experiment', args.pretrained) + else: + print('starting from epoch {}! ignoring pretrained model path..'.format(args.start_epoch)) + args.pretrained = '' + +if args.model == 'MSResNet': + args.gaussian_pyramid = True + +argname = os.path.join(args.save_dir, 'args.pt') +argname_txt = os.path.join(args.save_dir, 'args.txt') +if args.start_epoch > 1: + # load previous arguments and keep the necessary ones same + + if os.path.exists(argname): + args_old = torch.load(argname) + + load_list = [] # list of arguments that are fixed + # training + load_list += ['patch_size'] + load_list += ['batch_size'] + # data format + load_list += ['rgb_range'] + load_list += ['blur_key'] + # model architecture + load_list += ['n_scales'] + load_list += ['n_resblocks'] + load_list += ['n_feats'] + + for arg_part in load_list: + vars(args)[arg_part] = vars(args_old)[arg_part] + +if args.dataset is not None: + args.data_train = args.dataset + args.data_val = args.dataset if args.dataset != 'GOPRO_Large' else None + args.data_test = args.dataset + +if args.data_val is None: + args.do_validate = False + +if args.demo_input_dir: + args.demo = True + +if args.demo: + assert os.path.basename(args.save_dir) != now, 'You should specify pretrained directory by setting --save_dir SAVE_DIR' + + args.data_train = '' + args.data_val = '' + args.data_test = '' + + args.do_train = False + args.do_validate = False + args.do_test = False + + assert len(args.demo_input_dir) > 0, 'Please specify demo_input_dir!' + args.demo_input_dir = os.path.expanduser(args.demo_input_dir) + if args.demo_output_dir: + args.demo_output_dir = os.path.expanduser(args.demo_output_dir) + + args.save_results = 'all' + +if args.amp: + args.precision = 'single' # model parameters should stay in fp32 + +if args.seed < 0: + args.seed = int(time.time()) + +# save arguments +if args.rank == 0: + torch.save(args, argname) + with open(argname_txt, 'a') as file: + file.write('execution at {}\n'.format(now)) + + for key in args.__dict__: + file.write(key + ': ' + str(args.__dict__[key]) + '\n') + + file.write('\n') + +# device and type +if args.device_type == 'cuda' and not torch.cuda.is_available(): + raise Exception("GPU not available!") + +if not args.distributed: + args.rank = 0 + +def setup(args): + cudnn.benchmark = True + + if args.distributed: + os.environ['MASTER_ADDR'] = args.master_addr + os.environ['MASTER_PORT'] = args.master_port + + args.device_index = args.rank + args.world_size = args.n_GPUs # consider single-node training + + # initialize the process group + dist.init_process_group(args.dist_backend, init_method=args.init_method, rank=args.rank, world_size=args.world_size) + + args.device = torch.device(args.device_type, args.device_index) + args.dtype = torch.float32 + args.dtype_eval = torch.float32 if args.precision == 'single' else torch.float16 + + # set seed for processes (distributed: different seed for each process) + # model parameters are synchronized explicitly at initial + torch.manual_seed(args.seed) + if args.device_type == 'cuda': + torch.cuda.set_device(args.device) + if args.rank == 0: + torch.cuda.manual_seed_all(args.seed) + + return args + +def cleanup(args): + if args.distributed: + dist.destroy_process_group() diff --git a/backup/deblur/src/prepare.sh b/backup/deblur/src/prepare.sh new file mode 100644 index 0000000000000000000000000000000000000000..cd14ee9ff75b6870ae37f3175bb9b12aa283c4d9 --- /dev/null +++ b/backup/deblur/src/prepare.sh @@ -0,0 +1,16 @@ +#!/bin/bash +workplace=`pwd -P` + +if [ ! -d "/data/ssd/public/czli/deblur/GOPRO_Large" ]; then + workplace=`pwd` + echo "Copying dataset to ssd" + cd /research/dept7/liuhy/deblur/dataset + mkdir -p /data/ssd/public/czli/deblur/GOPRO_Large + cp GOPRO_Large.zip /data/ssd/public/czli/deblur/GOPRO_Large + cd /data/ssd/public/czli/deblur/GOPRO_Large + echo "Dumping zip in data path:" `pwd` + for f in *.zip; do unzip "$f"; done +fi + +cd "$workplace" +echo "Workplace:" `pwd` \ No newline at end of file diff --git a/backup/deblur/src/template.py b/backup/deblur/src/template.py new file mode 100644 index 0000000000000000000000000000000000000000..f06782dd96ebb447dd6f5a73ccfb698495689d3c --- /dev/null +++ b/backup/deblur/src/template.py @@ -0,0 +1,9 @@ +def set_template(args): + if args.template.find('gopro') >= 0: + args.dataset = 'GOPRO_Large' + args.milestones = [500, 750, 900] + args.end_epoch = 1000 + elif args.template.find('reds') >= 0: + args.dataset = 'REDS' + args.milestones = [100, 150, 180] + args.end_epoch = 200 diff --git a/backup/deblur/src/train-raft-range1.sh b/backup/deblur/src/train-raft-range1.sh new file mode 100644 index 0000000000000000000000000000000000000000..96f8779eb4455d143a3ef0d23e50b4202f73124e --- /dev/null +++ b/backup/deblur/src/train-raft-range1.sh @@ -0,0 +1,19 @@ +#!/bin/bash + +workplace=`pwd -P` + +if [ ! -d "/data/ssd/public/czli/deblur/GOPRO_Large" ]; then + workplace=`pwd` + echo "Copying dataset to ssd" + cd /research/dept7/liuhy/lambda/backup/deblur/dataset + mkdir -p /data/ssd/public/czli/deblur/GOPRO_Large + cp GOPRO_Large.zip /data/ssd/public/czli/deblur/GOPRO_Large + cd /data/ssd/public/czli/deblur/GOPRO_Large + echo "Dumping zip in data path:" `pwd` + for f in *.zip; do unzip "$f"; done +fi + +cd "$workplace" +echo "Workplace:" `pwd` +python launch.py --n_GPUs 2 main.py --batch_size 8 --save_dir RAFTNET_MSE_R5_rtx --n_scales 5 \ +--loss 1*MSE --model RaftNets --n_resblocks 10 --rgb_range 1 --clip 2 --decay_gamma 0.6 --amp true \ No newline at end of file diff --git a/backup/deblur/src/train-raft.sh b/backup/deblur/src/train-raft.sh new file mode 100644 index 0000000000000000000000000000000000000000..cce5491fd424b8f318f116d553fd01886380b62c --- /dev/null +++ b/backup/deblur/src/train-raft.sh @@ -0,0 +1,5 @@ +#!/bin/bash + +bash ./prepare.sh +python launch.py --n_GPUs 4 main.py --batch_size 12 --save_dir RAFTNET_L1_R6_test --n_scales 6 \ +--loss 1*L1 --model RaftNet --n_resblocks 10 --amp true --decay_gamma 0.5 \ No newline at end of file diff --git a/backup/deblur/src/train-rec-1.sh b/backup/deblur/src/train-rec-1.sh new file mode 100644 index 0000000000000000000000000000000000000000..331ba8fbe60542d290b38b0abf9adfbfc6f3d5ef --- /dev/null +++ b/backup/deblur/src/train-rec-1.sh @@ -0,0 +1,4 @@ +#!/bin/bash + +bash ./prepare.sh +python launch.py --n_GPUs 2 main.py --batch_size 16 --amp true --save_dir LamRes_L1 --n_scales 1 --loss 1*L1 \ No newline at end of file diff --git a/backup/deblur/src/train.py b/backup/deblur/src/train.py new file mode 100644 index 0000000000000000000000000000000000000000..aaaeb463c216e4246f71220057666676e249dc27 --- /dev/null +++ b/backup/deblur/src/train.py @@ -0,0 +1,250 @@ +import os +from tqdm import tqdm + +import torch + +import data.common +from utils import interact, MultiSaver +from torch.utils.tensorboard import SummaryWriter +import torchvision + +import torch.cuda.amp as amp + +class Trainer(): + + def __init__(self, args, model, criterion, optimizer, loaders): + print('===> Initializing trainer') + self.args = args + self.mode = 'train' # 'val', 'test' + self.epoch = args.start_epoch + self.save_dir = args.save_dir + + self.model = model + self.criterion = criterion + self.optimizer = optimizer + self.loaders = loaders + + + self.do_train = args.do_train + self.do_validate = args.do_validate + self.do_test = args.do_test + + self.device = args.device + self.dtype = args.dtype + self.dtype_eval = torch.float32 if args.precision == 'single' else torch.float16 + self.recurrence=args.n_scales + if self.args.demo and self.args.demo_output_dir: + self.result_dir = self.args.demo_output_dir + else: + self.result_dir = os.path.join(self.save_dir, 'result') + os.makedirs(self.result_dir, exist_ok=True) + print('results are saved in {}'.format(self.result_dir)) + + self.imsaver = MultiSaver(self.result_dir) + + self.is_slave = self.args.launched and self.args.rank != 0 + + self.scaler = amp.GradScaler( + init_scale=self.args.init_scale, + enabled=self.args.amp + ) + if not self.is_slave: + self.writter=SummaryWriter(f"runs/{args.save_dir}") + + + def save(self, epoch=None): + epoch = self.epoch if epoch is None else epoch + if epoch % self.args.save_every == 0: + if self.mode == 'train': + self.model.save(epoch) + self.optimizer.save(epoch) + self.criterion.save() + + return + + def load(self, epoch=None, pretrained=None): + if epoch is None: + epoch = self.args.load_epoch + self.epoch = epoch + self.model.load(epoch, pretrained) + self.optimizer.load(epoch) + self.criterion.load(epoch) + + return + + def train(self, epoch): + self.mode = 'train' + self.epoch = epoch + + self.model.train() + self.model.to(dtype=self.dtype) + + self.criterion.train() + self.criterion.epoch = epoch + + if not self.is_slave: + print('[Epoch {} / lr {:.2e}]'.format( + epoch, self.optimizer.get_lr() + )) + total=len(self.loaders[self.mode]) + acc=0.0 + if self.args.distributed: + self.loaders[self.mode].sampler.set_epoch(epoch) + if self.is_slave: + tq = self.loaders[self.mode] + else: + tq = tqdm(self.loaders[self.mode], ncols=80, smoothing=0, bar_format='{desc}|{bar}{r_bar}') + buffer=[0.0]*self.recurrence + torch.set_grad_enabled(True) + for idx, batch in enumerate(tq): + self.optimizer.zero_grad() + + input, target = data.common.to( + batch[0], batch[1], device=self.device, dtype=self.dtype) + # print(input[0].max(),input[0].min(),target[0].max(),target[0].min()) + # exit(1) + with amp.autocast(self.args.amp): + output = self.model(input) + loss = self.criterion(output, target) + + for i in range(self.recurrence): + buffer[i]+=self.criterion.buffer[i] + + self.scaler.scale(loss).backward() + if self.args.clip>0: + self.scaler.unscale_(self.optimizer.G) + torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.args.clip) + self.scaler.step(self.optimizer.G) + self.scaler.update() + + if isinstance(tq, tqdm): + tq.set_description(self.criterion.get_loss_desc()) + if not self.is_slave: + rgb_range=self.args.rgb_range + for i in range(len(output)): + grid=torchvision.utils.make_grid(output[i]) + self.writter.add_image(f"Output{i}",grid/rgb_range,epoch) + self.writter.add_scalar(f"Loss{i}",buffer[i],epoch) + self.writter.add_image("Input",torchvision.utils.make_grid(input[0])/rgb_range,epoch) + self.writter.add_image("Target",torchvision.utils.make_grid(target[0])/rgb_range,epoch) + self.criterion.normalize() + if isinstance(tq, tqdm): + tq.set_description(self.criterion.get_loss_desc()) + tq.display(pos=-1) # overwrite with synchronized loss + + self.criterion.step() + self.optimizer.schedule(self.criterion.get_last_loss()) + + if self.args.rank == 0: + self.save(epoch) + + return + + def evaluate(self, epoch, mode='val'): + self.mode = mode + self.epoch = epoch + + self.model.eval() + self.model.to(dtype=self.dtype_eval) + + if mode == 'val': + self.criterion.validate() + elif mode == 'test': + self.criterion.test() + self.criterion.epoch = epoch + + self.imsaver.join_background() + + if self.is_slave: + tq = self.loaders[self.mode] + else: + tq = tqdm(self.loaders[self.mode], ncols=80, smoothing=0, bar_format='{desc}|{bar}{r_bar}') + + compute_loss = True + torch.set_grad_enabled(False) + for idx, batch in enumerate(tq): + input, target = data.common.to( + batch[0], batch[1], device=self.device, dtype=self.dtype_eval) + with amp.autocast(self.args.amp): + output = self.model(input) + + # if self.args.rgb_range==1: + # output=output*255 + # target=target*255 + + if mode == 'demo': # remove padded part + pad_width = batch[2] + output[0], _ = data.common.pad(output[0], pad_width=pad_width, negative=True) + + if isinstance(batch[1], torch.BoolTensor): + compute_loss = False + + if compute_loss: + self.criterion(output, target) + if isinstance(tq, tqdm): + tq.set_description(self.criterion.get_loss_desc()) + + if self.args.save_results != 'none': + if isinstance(output, (list, tuple)): + result = output[-1] # select last output in a pyramid + elif isinstance(output, torch.Tensor): + result = output + + names = batch[-1] + + if self.args.save_results == 'part' and compute_loss: # save all when GT not available + indices = batch[-2] + save_ids = [save_id for save_id, idx in enumerate(indices) if idx % 10 == 0] + + result = result[save_ids] + names = [names[save_id] for save_id in save_ids] + + self.imsaver.save_image(result, names) + + if compute_loss: + self.criterion.normalize() + if isinstance(tq, tqdm): + tq.set_description(self.criterion.get_loss_desc()) + tq.display(pos=-1) # overwrite with synchronized loss + + self.criterion.step() + if self.args.rank == 0: + self.save() + + self.imsaver.end_background() + + def validate(self, epoch): + self.evaluate(epoch, 'val') + return + + def test(self, epoch): + self.evaluate(epoch, 'test') + return + + def fill_evaluation(self, epoch, mode=None, force=False): + if epoch <= 0: + return + + if mode is not None: + self.mode = mode + + do_eval = force + if not force: + loss_missing = epoch not in self.criterion.loss_stat[self.mode]['Total'] # should it switch to all loss types? + + metric_missing = False + for metric_type in self.criterion.metric: + if epoch not in self.criterion.metric_stat[mode][metric_type]: + metric_missing = True + + do_eval = loss_missing or metric_missing + + if do_eval: + try: + self.load(epoch) + self.evaluate(epoch, self.mode) + except: + # print('saved model/optimizer at epoch {} not found!'.format(epoch)) + pass + + return diff --git a/backup/deblur/src/train.sh b/backup/deblur/src/train.sh new file mode 100644 index 0000000000000000000000000000000000000000..8fa1839a035d78d6f0b9746e70a0c9778cd1f6a0 --- /dev/null +++ b/backup/deblur/src/train.sh @@ -0,0 +1,4 @@ +#!/bin/bash + +bash ./prepare.sh +python launch.py --n_GPUs 2 main.py --batch_size 16 --amp true --save_dir RecLamRes_MSE \ No newline at end of file diff --git a/backup/deblur/src/train01.sh b/backup/deblur/src/train01.sh new file mode 100644 index 0000000000000000000000000000000000000000..8ca27d27729a1751b7f9f7dafd4fd9d5148ef66c --- /dev/null +++ b/backup/deblur/src/train01.sh @@ -0,0 +1,4 @@ +#!/bin/bash + +bash ./prepare.sh +CUDA_VISIBLE_DEVICES=0,1 python launch.py --n_GPUs 2 main.py --batch_size 16 --amp true --save_dir RecLamRes_MSE \ No newline at end of file diff --git a/backup/deblur/src/train23.sh b/backup/deblur/src/train23.sh new file mode 100644 index 0000000000000000000000000000000000000000..33deb73c692a439381e2c5ea63608e1e8bf01e98 --- /dev/null +++ b/backup/deblur/src/train23.sh @@ -0,0 +1,4 @@ +#!/bin/bash + +bash ./prepare.sh +CUDA_VISIBLE_DEVICES=2,3 python launch.py --n_GPUs 2 main.py --batch_size 8 --amp true --save_dir RecLamRes_MSE_detach --detach true --master_port 8025 \ No newline at end of file diff --git a/backup/deblur/src/utils.py b/backup/deblur/src/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..19525ef5796edad631292adf403730c2ab98a929 --- /dev/null +++ b/backup/deblur/src/utils.py @@ -0,0 +1,200 @@ +import readline +import rlcompleter +readline.parse_and_bind("tab: complete") +import code +import pdb + +import time +import argparse +import os +import imageio +import torch +import torch.multiprocessing as mp + +# debugging tools +def interact(local=None): + """interactive console with autocomplete function. Useful for debugging. + interact(locals()) + """ + if local is None: + local=dict(globals(), **locals()) + + readline.set_completer(rlcompleter.Completer(local).complete) + code.interact(local=local) + +def set_trace(local=None): + """debugging with pdb + """ + if local is None: + local=dict(globals(), **locals()) + + pdb.Pdb.complete = rlcompleter.Completer(local).complete + pdb.set_trace() + +# timer +class Timer(): + """Brought from https://github.com/thstkdgus35/EDSR-PyTorch + """ + def __init__(self): + self.acc = 0 + self.tic() + + def tic(self): + self.t0 = time.time() + + def toc(self): + return time.time() - self.t0 + + def hold(self): + self.acc += self.toc() + + def release(self): + ret = self.acc + self.acc = 0 + + return ret + + def reset(self): + self.acc = 0 + + +# argument parser type casting functions +def str2bool(val): + """enable default constant true arguments""" + # https://stackoverflow.com/questions/15008758/parsing-boolean-values-with-argparse + if isinstance(val, bool): + return val + elif val.lower() == 'true': + return True + elif val.lower() == 'false': + return False + else: + raise argparse.ArgumentTypeError('Boolean value expected') + +def int2str(val): + """convert int to str for environment variable related arguments""" + if isinstance(val, int): + return str(val) + elif isinstance(val, str): + return val + else: + raise argparse.ArgumentTypeError('number value expected') + + +# image saver using multiprocessing queue +class MultiSaver(): + def __init__(self, result_dir=None): + self.queue = None + self.process = None + self.result_dir = result_dir + + def begin_background(self): + self.queue = mp.Queue() + + def t(queue): + while True: + if queue.empty(): + continue + img, name = queue.get() + if name: + try: + basename, ext = os.path.splitext(name) + if ext != '.png': + name = '{}.png'.format(basename) + imageio.imwrite(name, img) + except Exception as e: + print(e) + else: + return + + worker = lambda: mp.Process(target=t, args=(self.queue,), daemon=False) + cpu_count = min(8, mp.cpu_count() - 1) + self.process = [worker() for _ in range(cpu_count)] + for p in self.process: + p.start() + + def end_background(self): + if self.queue is None: + return + + for _ in self.process: + self.queue.put((None, None)) + + def join_background(self): + if self.queue is None: + return + + while not self.queue.empty(): + time.sleep(0.5) + + for p in self.process: + p.join() + + self.queue = None + + def save_image(self, output, save_names, result_dir=None): + result_dir = result_dir if self.result_dir is None else self.result_dir + if result_dir is None: + raise Exception('no result dir specified!') + + if self.queue is None: + try: + self.begin_background() + except Exception as e: + print(e) + return + + # assume NCHW format + if output.ndim == 2: + output = output.expand([1, 1] + list(output.shape)) + elif output.ndim == 3: + output = output.expand([1] + list(output.shape)) + + for output_img, save_name in zip(output, save_names): + # assume image range [0, 255] + output_img = output_img.add_(0.5).clamp_(0, 255).permute(1, 2, 0).to('cpu', torch.uint8).numpy() + + save_name = os.path.join(result_dir, save_name) + save_dir = os.path.dirname(save_name) + os.makedirs(save_dir, exist_ok=True) + + self.queue.put((output_img, save_name)) + + return + +class Map(dict): + """ + https://stackoverflow.com/questions/2352181/how-to-use-a-dot-to-access-members-of-dictionary + Example: + m = Map({'first_name': 'Eduardo'}, last_name='Pool', age=24, sports=['Soccer']) + """ + def __init__(self, *args, **kwargs): + super(Map, self).__init__(*args, **kwargs) + for arg in args: + if isinstance(arg, dict): + for k, v in arg.items(): + self[k] = v + + if kwargs: + for k, v in kwargs.items(): + self[k] = v + + def __getattr__(self, attr): + return self.get(attr) + + def __setattr__(self, key, value): + self.__setitem__(key, value) + + def __setitem__(self, key, value): + super(Map, self).__setitem__(key, value) + self.__dict__.update({key: value}) + + def __delattr__(self, item): + self.__delitem__(item) + + def __delitem__(self, key): + super(Map, self).__delitem__(key) + del self.__dict__[key] + + def toDict(self): + return self.__dict__ \ No newline at end of file diff --git a/backup/deblur/src/utils.pyc b/backup/deblur/src/utils.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a1e1c9a8f2f7b53e20cbe3b52177ae279415f967 Binary files /dev/null and b/backup/deblur/src/utils.pyc differ