diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..7edf665b0d69301c66dfdd231d2cd06ca9ffe164 --- /dev/null +++ b/.gitignore @@ -0,0 +1,139 @@ +# ignored folders +datasets/* +experiments/* +results/* +tb_logger/* +wandb/* +tmp/* + +*.DS_Store +.idea +.vscode +.github + +.onnx + +# ignored files +version.py + +# ignored files with suffix +*.html +*.png +*.jpeg +*.jpg +*.gif +*.pth +*.zip +*.npy + +# template + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# 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/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 + +# 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 + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ + +# meta file +data_list/*.txt + +weights/ \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f49a4e16e68b128803cc2dcea614603632b04eac --- /dev/null +++ b/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. \ No newline at end of file diff --git a/MODEL_ZOO.md b/MODEL_ZOO.md new file mode 100644 index 0000000000000000000000000000000000000000..5299083ecd45e1b2749eaba0eda851445a9d17f3 --- /dev/null +++ b/MODEL_ZOO.md @@ -0,0 +1,13 @@ +## DDColor Model Zoo + +| Model | Description | Note | +| ---------------------- | :------------------ | :-----| +| [ddcolor_paper.pth](https://huggingface.co/piddnad/DDColor-models/resolve/main/ddcolor_paper.pth) | DDColor-L trained on ImageNet | paper model, use it only if you want to reproduce some of the images in the paper. +| [ddcolor_modelscope.pth](https://huggingface.co/piddnad/DDColor-models/resolve/main/ddcolor_modelscope.pth) (***default***) | DDColor-L trained on ImageNet | We trained this model using the same data cleaning scheme as [BigColor](https://github.com/KIMGEONUNG/BigColor/issues/2#issuecomment-1196287574), so it can get the best qualitative results with little degrading FID performance. Use this model by default if you want to test images outside the ImageNet. It can also be easily downloaded through ModelScope [in this way](README.md#inference-with-modelscope-library). +| [ddcolor_artistic.pth](https://huggingface.co/piddnad/DDColor-models/resolve/main/ddcolor_artistic.pth) | DDColor-L trained on ImageNet + private data | We trained this model with an extended dataset containing many high-quality artistic images. Also, we didn't use colorfulness loss during training, so there may be fewer unreasonable color artifacts. Use this model if you want to try different colorization results. +| [ddcolor_paper_tiny.pth](https://huggingface.co/piddnad/DDColor-models/resolve/main/ddcolor_paper_tiny.pth) | DDColor-T trained on ImageNet | The most lightweight version of ddcolor model, using the same training scheme as ddcolor_paper. + +## Discussions + +* About Colorfulness Loss (CL): CL can encourage more "colorful" results and help improve CF scores, however, it sometimes leads to the generation of unpleasant color blocks (eg. red color artifacts). If something goes wrong, I personally recommend trying to remove it during training. + diff --git a/README.md b/README.md index 96d568b3d516daa3563490b7e525907133e58ede..3a79a418980611b550f9d92dda746eb758bc6d35 100644 --- a/README.md +++ b/README.md @@ -1,12 +1,206 @@ --- title: DDColor -emoji: 🚀 -colorFrom: gray -colorTo: pink +app_file: gradio_app.py sdk: gradio -sdk_version: 5.23.3 -app_file: app.py -pinned: false +sdk_version: 5.21.0 --- +# 🎨 DDColor +[![arXiv](https://img.shields.io/badge/arXiv-2212.11613-b31b1b.svg)](https://arxiv.org/abs/2212.11613) +[![HuggingFace](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Models-FF8000)](https://huggingface.co/piddnad/DDColor-models) +[![ModelScope demo](https://img.shields.io/badge/%F0%9F%91%BE%20ModelScope-Demo-8A2BE2)](https://www.modelscope.cn/models/damo/cv_ddcolor_image-colorization/summary) +[![Replicate](https://replicate.com/piddnad/ddcolor/badge)](https://replicate.com/piddnad/ddcolor) +![visitors](https://visitor-badge.laobi.icu/badge?page_id=piddnad/DDColor) -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference +Official PyTorch implementation of ICCV 2023 Paper "DDColor: Towards Photo-Realistic Image Colorization via Dual Decoders". + +> Xiaoyang Kang, Tao Yang, Wenqi Ouyang, Peiran Ren, Lingzhi Li, Xuansong Xie +> *DAMO Academy, Alibaba Group* + +🪄 DDColor can provide vivid and natural colorization for historical black and white old photos. + +

+ +

+ +🎲 It can even colorize/recolor landscapes from anime games, transforming your animated scenery into a realistic real-life style! (Image source: Genshin Impact) + +

+ +

+ + +## News +- [2024-01-28] Support inference via 🤗 Hugging Face! Thanks @[Niels](https://github.com/NielsRogge) for the suggestion and example code and @[Skwara](https://github.com/Skwarson96) for fixing bug. +- [2024-01-18] Add Replicate demo and API! Thanks @[Chenxi](https://github.com/chenxwh). +- [2023-12-13] Release the DDColor-tiny pre-trained model! +- [2023-09-07] Add the Model Zoo and release three pretrained models! +- [2023-05-15] Code release for training and inference! +- [2023-05-05] The online demo is available! + + +## Online Demo +Try our online demos at [ModelScope](https://www.modelscope.cn/models/damo/cv_ddcolor_image-colorization/summary) and [Replicate](https://replicate.com/piddnad/ddcolor). + + +## Methods +*In short:* DDColor uses multi-scale visual features to optimize **learnable color tokens** (i.e. color queries) and achieves state-of-the-art performance on automatic image colorization. + +

+ +

+ + +## Installation +### Requirements +- Python >= 3.7 +- PyTorch >= 1.7 + +### Installation with conda (recommended) + +```sh +conda create -n ddcolor python=3.9 +conda activate ddcolor +pip install torch==2.2.0 torchvision==0.17.0 torchaudio==2.2.0 --index-url https://download.pytorch.org/whl/cu118 + +pip install -r requirements.txt + +# Install basicsr, only required for training +python3 setup.py develop +``` + +## Quick Start +### Inference Using Local Script (No `basicsr` Required) +1. Download the pretrained model: + +```python +from modelscope.hub.snapshot_download import snapshot_download + +model_dir = snapshot_download('damo/cv_ddcolor_image-colorization', cache_dir='./modelscope') +print('model assets saved to %s' % model_dir) +``` + +2. Run inference with + +```sh +python infer.py --model_path ./modelscope/damo/cv_ddcolor_image-colorization/pytorch_model.pt --input ./assets/test_images +``` +or +```sh +sh scripts/inference.sh +``` + +### Inference Using Hugging Face +Load the model via Hugging Face Hub: + +```python +from infer_hf import DDColorHF + +ddcolor_paper_tiny = DDColorHF.from_pretrained("piddnad/ddcolor_paper_tiny") +ddcolor_paper = DDColorHF.from_pretrained("piddnad/ddcolor_paper") +ddcolor_modelscope = DDColorHF.from_pretrained("piddnad/ddcolor_modelscope") +ddcolor_artistic = DDColorHF.from_pretrained("piddnad/ddcolor_artistic") +``` + +Check `infer_hf.py` for the details of the inference, or directly perform model inference by running: + +```sh +python infer_hf.py --model_name ddcolor_modelscope --input ./assets/test_images +# model_name: [ddcolor_paper | ddcolor_modelscope | ddcolor_artistic | ddcolor_paper_tiny] +``` + +### Inference Using ModelScope +1. Install modelscope: + +```sh +pip install modelscope +``` + +2. Run inference: + +```python +import cv2 +from modelscope.outputs import OutputKeys +from modelscope.pipelines import pipeline +from modelscope.utils.constant import Tasks + +img_colorization = pipeline(Tasks.image_colorization, model='damo/cv_ddcolor_image-colorization') +result = img_colorization('https://modelscope.oss-cn-beijing.aliyuncs.com/test/images/audrey_hepburn.jpg') +cv2.imwrite('result.png', result[OutputKeys.OUTPUT_IMG]) +``` + +This code will automatically download the `ddcolor_modelscope` model (see [ModelZoo](#model-zoo)) and performs inference. The model file `pytorch_model.pt` can be found in the local path `~/.cache/modelscope/hub/damo`. + +### Gradio Demo +Install the gradio and other required libraries: + +```sh +pip install gradio gradio_imageslider timm +``` + +Then, you can run the demo with the following command: + +```sh +python gradio_app.py +``` + +## Model Zoo +We provide several different versions of pretrained models, please check out [Model Zoo](MODEL_ZOO.md). + + +## Train +1. Dataset Preparation: Download the [ImageNet](https://www.image-net.org/) dataset or create a custom dataset. Use this script to obtain the dataset list file: + +```sh +python data_list/get_meta_file.py +``` + +2. Download the pretrained weights for [ConvNeXt](https://dl.fbaipublicfiles.com/convnext/convnext_large_22k_224.pth) and [InceptionV3](https://download.pytorch.org/models/inception_v3_google-1a9a5a14.pth) and place them in the `pretrain` folder. + +3. Specify 'meta_info_file' and other options in `options/train/train_ddcolor.yml`. + +4. Start training: + +```sh +sh scripts/train.sh +``` + +## ONNX export +Support for ONNX model exports is available. + +1. Install dependencies: + +```sh +pip install onnx==1.16.1 onnxruntime==1.19.2 onnxsim==0.4.36 +``` + +2. Usage example: + +```sh +python export.py +usage: export.py [-h] [--input_size INPUT_SIZE] [--batch_size BATCH_SIZE] --model_path MODEL_PATH [--model_size MODEL_SIZE] +[--decoder_type DECODER_TYPE] [--export_path EXPORT_PATH] [--opset OPSET] +``` + +Demo of ONNX export using a `ddcolor_paper_tiny` model is available [here](notebooks/colorization_pipeline_onnxruntime.ipynb). + + +## Citation + +If our work is helpful for your research, please consider citing: + +``` +@inproceedings{kang2023ddcolor, + title={DDColor: Towards Photo-Realistic Image Colorization via Dual Decoders}, + author={Kang, Xiaoyang and Yang, Tao and Ouyang, Wenqi and Ren, Peiran and Li, Lingzhi and Xie, Xuansong}, + booktitle={Proceedings of the IEEE/CVF International Conference on Computer Vision}, + pages={328--338}, + year={2023} +} +``` + +## Acknowledgments +We thank the authors of BasicSR for the awesome training pipeline. + +> Xintao Wang, Ke Yu, Kelvin C.K. Chan, Chao Dong and Chen Change Loy. BasicSR: Open Source Image and Video Restoration Toolbox. https://github.com/xinntao/BasicSR, 2020. + +Some codes are adapted from [ColorFormer](https://github.com/jixiaozhong/ColorFormer), [BigColor](https://github.com/KIMGEONUNG/BigColor), [ConvNeXt](https://github.com/facebookresearch/ConvNeXt), [Mask2Former](https://github.com/facebookresearch/Mask2Former), and [DETR](https://github.com/facebookresearch/detr). Thanks for their excellent work! diff --git a/VERSION b/VERSION new file mode 100644 index 0000000000000000000000000000000000000000..ac2cb1ce5b8e6fc84799d048f9b8fd6fe5118e2b --- /dev/null +++ b/VERSION @@ -0,0 +1 @@ +1.3.4.6 diff --git a/basicsr/__init__.py b/basicsr/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f1b6f288effaa34d626bf5cc9fc183f8c4c67fee --- /dev/null +++ b/basicsr/__init__.py @@ -0,0 +1,15 @@ +# https://github.com/xinntao/BasicSR +# flake8: noqa +from .archs import * +from .data import * +from .losses import * +from .metrics import * +from .models import * +# from .ops import * +# from .test import * +from .train import * +from .utils import * +try: + from .version import __gitsha__, __version__ +except: + pass diff --git a/basicsr/archs/__init__.py b/basicsr/archs/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cfb1e4d7bb221c429082bd389d9140e5b1cc07b0 --- /dev/null +++ b/basicsr/archs/__init__.py @@ -0,0 +1,25 @@ +import importlib +from copy import deepcopy +from os import path as osp + +from basicsr.utils import get_root_logger, scandir +from basicsr.utils.registry import ARCH_REGISTRY + +__all__ = ['build_network'] + +# automatically scan and import arch modules for registry +# scan all the files under the 'archs' folder and collect files ending with +# '_arch.py' +arch_folder = osp.dirname(osp.abspath(__file__)) +arch_filenames = [osp.splitext(osp.basename(v))[0] for v in scandir(arch_folder) if v.endswith('_arch.py')] +# import all the arch modules +_arch_modules = [importlib.import_module(f'basicsr.archs.{file_name}') for file_name in arch_filenames] + + +def build_network(opt): + opt = deepcopy(opt) + network_type = opt.pop('type') + net = ARCH_REGISTRY.get(network_type)(**opt) + logger = get_root_logger() + logger.info(f'Network [{net.__class__.__name__}] is created.') + return net diff --git a/basicsr/archs/ddcolor_arch.py b/basicsr/archs/ddcolor_arch.py new file mode 100644 index 0000000000000000000000000000000000000000..098ac74bbe24fd48a9a11dd05dbae3b40145b538 --- /dev/null +++ b/basicsr/archs/ddcolor_arch.py @@ -0,0 +1,385 @@ +import torch +import torch.nn as nn + +from basicsr.archs.ddcolor_arch_utils.unet import Hook, CustomPixelShuffle_ICNR, UnetBlockWide, NormType, custom_conv_layer +from basicsr.archs.ddcolor_arch_utils.convnext import ConvNeXt +from basicsr.archs.ddcolor_arch_utils.transformer_utils import SelfAttentionLayer, CrossAttentionLayer, FFNLayer, MLP +from basicsr.archs.ddcolor_arch_utils.position_encoding import PositionEmbeddingSine +from basicsr.archs.ddcolor_arch_utils.transformer import Transformer +from basicsr.utils.registry import ARCH_REGISTRY + + +@ARCH_REGISTRY.register() +class DDColor(nn.Module): + + def __init__(self, + encoder_name='convnext-l', + decoder_name='MultiScaleColorDecoder', + num_input_channels=3, + input_size=(256, 256), + nf=512, + num_output_channels=3, + last_norm='Weight', + do_normalize=False, + num_queries=256, + num_scales=3, + dec_layers=9, + encoder_from_pretrain=False): + super().__init__() + + self.encoder = Encoder(encoder_name, ['norm0', 'norm1', 'norm2', 'norm3'], from_pretrain=encoder_from_pretrain) + self.encoder.eval() + test_input = torch.randn(1, num_input_channels, *input_size) + self.encoder(test_input) + + self.decoder = Decoder( + self.encoder.hooks, + nf=nf, + last_norm=last_norm, + num_queries=num_queries, + num_scales=num_scales, + dec_layers=dec_layers, + decoder_name=decoder_name + ) + self.refine_net = nn.Sequential(custom_conv_layer(num_queries + 3, num_output_channels, ks=1, use_activ=False, norm_type=NormType.Spectral)) + + self.do_normalize = do_normalize + self.register_buffer('mean', torch.Tensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1)) + self.register_buffer('std', torch.Tensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1)) + + def normalize(self, img): + return (img - self.mean) / self.std + + def denormalize(self, img): + return img * self.std + self.mean + + def forward(self, x): + if x.shape[1] == 3: + x = self.normalize(x) + + self.encoder(x) + out_feat = self.decoder() + coarse_input = torch.cat([out_feat, x], dim=1) + out = self.refine_net(coarse_input) + + if self.do_normalize: + out = self.denormalize(out) + return out + + +class Decoder(nn.Module): + + def __init__(self, + hooks, + nf=512, + blur=True, + last_norm='Weight', + num_queries=256, + num_scales=3, + dec_layers=9, + decoder_name='MultiScaleColorDecoder'): + super().__init__() + self.hooks = hooks + self.nf = nf + self.blur = blur + self.last_norm = getattr(NormType, last_norm) + self.decoder_name = decoder_name + + self.layers = self.make_layers() + embed_dim = nf // 2 + + self.last_shuf = CustomPixelShuffle_ICNR(embed_dim, embed_dim, blur=self.blur, norm_type=self.last_norm, scale=4) + + if self.decoder_name == 'MultiScaleColorDecoder': + self.color_decoder = MultiScaleColorDecoder( + in_channels=[512, 512, 256], + num_queries=num_queries, + num_scales=num_scales, + dec_layers=dec_layers, + ) + else: + self.color_decoder = SingleColorDecoder( + in_channels=hooks[-1].feature.shape[1], + num_queries=num_queries, + ) + + + def forward(self): + encode_feat = self.hooks[-1].feature + out0 = self.layers[0](encode_feat) + out1 = self.layers[1](out0) + out2 = self.layers[2](out1) + out3 = self.last_shuf(out2) + + if self.decoder_name == 'MultiScaleColorDecoder': + out = self.color_decoder([out0, out1, out2], out3) + else: + out = self.color_decoder(out3, encode_feat) + + return out + + def make_layers(self): + decoder_layers = [] + + e_in_c = self.hooks[-1].feature.shape[1] + in_c = e_in_c + + out_c = self.nf + setup_hooks = self.hooks[-2::-1] + for layer_index, hook in enumerate(setup_hooks): + feature_c = hook.feature.shape[1] + if layer_index == len(setup_hooks) - 1: + out_c = out_c // 2 + decoder_layers.append( + UnetBlockWide( + in_c, feature_c, out_c, hook, blur=self.blur, self_attention=False, norm_type=NormType.Spectral)) + in_c = out_c + return nn.Sequential(*decoder_layers) + + +class Encoder(nn.Module): + + def __init__(self, encoder_name, hook_names, from_pretrain, **kwargs): + super().__init__() + + if encoder_name == 'convnext-t' or encoder_name == 'convnext': + self.arch = ConvNeXt() + elif encoder_name == 'convnext-s': + self.arch = ConvNeXt(depths=[3, 3, 27, 3], dims=[96, 192, 384, 768]) + elif encoder_name == 'convnext-b': + self.arch = ConvNeXt(depths=[3, 3, 27, 3], dims=[128, 256, 512, 1024]) + elif encoder_name == 'convnext-l': + self.arch = ConvNeXt(depths=[3, 3, 27, 3], dims=[192, 384, 768, 1536]) + else: + raise NotImplementedError + + self.encoder_name = encoder_name + self.hook_names = hook_names + self.hooks = self.setup_hooks() + + if from_pretrain: + self.load_pretrain_model() + + def setup_hooks(self): + hooks = [Hook(self.arch._modules[name]) for name in self.hook_names] + return hooks + + def forward(self, x): + return self.arch(x) + + def load_pretrain_model(self): + if self.encoder_name == 'convnext-t' or self.encoder_name == 'convnext': + self.load('pretrain/convnext_tiny_22k_224.pth') + elif self.encoder_name == 'convnext-s': + self.load('pretrain/convnext_small_22k_224.pth') + elif self.encoder_name == 'convnext-b': + self.load('pretrain/convnext_base_22k_224.pth') + elif self.encoder_name == 'convnext-l': + self.load('pretrain/convnext_large_22k_224.pth') + else: + raise NotImplementedError + print('Loaded pretrained convnext model.') + + def load(self, path): + from basicsr.utils import get_root_logger + logger = get_root_logger() + if not path: + logger.info("No checkpoint found. Initializing model from scratch") + return + logger.info("[Encoder] Loading from {} ...".format(path)) + checkpoint = torch.load(path, map_location=torch.device("cpu")) + checkpoint_state_dict = checkpoint['model'] if 'model' in checkpoint.keys() else checkpoint + incompatible = self.arch.load_state_dict(checkpoint_state_dict, strict=False) + + if incompatible.missing_keys: + msg = "Some model parameters or buffers are not found in the checkpoint:\n" + msg += str(incompatible.missing_keys) + logger.warning(msg) + if incompatible.unexpected_keys: + msg = "The checkpoint state_dict contains keys that are not used by the model:\n" + msg += str(incompatible.unexpected_keys) + logger.warning(msg) + + +class MultiScaleColorDecoder(nn.Module): + + def __init__( + self, + in_channels, + hidden_dim=256, + num_queries=100, + nheads=8, + dim_feedforward=2048, + dec_layers=9, + pre_norm=False, + color_embed_dim=256, + enforce_input_project=True, + num_scales=3 + ): + super().__init__() + + # positional encoding + N_steps = hidden_dim // 2 + self.pe_layer = PositionEmbeddingSine(N_steps, normalize=True) + + # define Transformer decoder here + self.num_heads = nheads + self.num_layers = dec_layers + self.transformer_self_attention_layers = nn.ModuleList() + self.transformer_cross_attention_layers = nn.ModuleList() + self.transformer_ffn_layers = nn.ModuleList() + + for _ in range(self.num_layers): + self.transformer_self_attention_layers.append( + SelfAttentionLayer( + d_model=hidden_dim, + nhead=nheads, + dropout=0.0, + normalize_before=pre_norm, + ) + ) + self.transformer_cross_attention_layers.append( + CrossAttentionLayer( + d_model=hidden_dim, + nhead=nheads, + dropout=0.0, + normalize_before=pre_norm, + ) + ) + self.transformer_ffn_layers.append( + FFNLayer( + d_model=hidden_dim, + dim_feedforward=dim_feedforward, + dropout=0.0, + normalize_before=pre_norm, + ) + ) + + self.decoder_norm = nn.LayerNorm(hidden_dim) + + self.num_queries = num_queries + # learnable color query features + self.query_feat = nn.Embedding(num_queries, hidden_dim) + # learnable color query p.e. + self.query_embed = nn.Embedding(num_queries, hidden_dim) + + # level embedding + self.num_feature_levels = num_scales + self.level_embed = nn.Embedding(self.num_feature_levels, hidden_dim) + + # input projections + self.input_proj = nn.ModuleList() + for i in range(self.num_feature_levels): + if in_channels[i] != hidden_dim or enforce_input_project: + self.input_proj.append(nn.Conv2d(in_channels[i], hidden_dim, kernel_size=1)) + nn.init.kaiming_uniform_(self.input_proj[-1].weight, a=1) + if self.input_proj[-1].bias is not None: + nn.init.constant_(self.input_proj[-1].bias, 0) + else: + self.input_proj.append(nn.Sequential()) + + # output FFNs + self.color_embed = MLP(hidden_dim, hidden_dim, color_embed_dim, 3) + + def forward(self, x, img_features): + # x is a list of multi-scale feature + assert len(x) == self.num_feature_levels + src = [] + pos = [] + + for i in range(self.num_feature_levels): + pos.append(self.pe_layer(x[i], None).flatten(2)) + src.append(self.input_proj[i](x[i]).flatten(2) + self.level_embed.weight[i][None, :, None]) + + # flatten NxCxHxW to HWxNxC + pos[-1] = pos[-1].permute(2, 0, 1) + src[-1] = src[-1].permute(2, 0, 1) + + _, bs, _ = src[0].shape + + # QxNxC + query_embed = self.query_embed.weight.unsqueeze(1).repeat(1, bs, 1) + output = self.query_feat.weight.unsqueeze(1).repeat(1, bs, 1) + + for i in range(self.num_layers): + level_index = i % self.num_feature_levels + # attention: cross-attention first + output = self.transformer_cross_attention_layers[i]( + output, src[level_index], + memory_mask=None, + memory_key_padding_mask=None, + pos=pos[level_index], query_pos=query_embed + ) + output = self.transformer_self_attention_layers[i]( + output, tgt_mask=None, + tgt_key_padding_mask=None, + query_pos=query_embed + ) + # FFN + output = self.transformer_ffn_layers[i]( + output + ) + + decoder_output = self.decoder_norm(output) + decoder_output = decoder_output.transpose(0, 1) # [N, bs, C] -> [bs, N, C] + color_embed = self.color_embed(decoder_output) + out = torch.einsum("bqc,bchw->bqhw", color_embed, img_features) + + return out + + +class SingleColorDecoder(nn.Module): + + def __init__( + self, + in_channels=768, + hidden_dim=256, + num_queries=256, # 100 + nheads=8, + dropout=0.1, + dim_feedforward=2048, + enc_layers=0, + dec_layers=6, + pre_norm=False, + deep_supervision=True, + enforce_input_project=True, + ): + + super().__init__() + + N_steps = hidden_dim // 2 + self.pe_layer = PositionEmbeddingSine(N_steps, normalize=True) + + transformer = Transformer( + d_model=hidden_dim, + dropout=dropout, + nhead=nheads, + dim_feedforward=dim_feedforward, + num_encoder_layers=enc_layers, + num_decoder_layers=dec_layers, + normalize_before=pre_norm, + return_intermediate_dec=deep_supervision, + ) + self.num_queries = num_queries + self.transformer = transformer + + self.query_embed = nn.Embedding(num_queries, hidden_dim) + + if in_channels != hidden_dim or enforce_input_project: + self.input_proj = nn.Conv2d(in_channels, hidden_dim, kernel_size=1) + nn.init.kaiming_uniform_(self.input_proj.weight, a=1) + if self.input_proj.bias is not None: + nn.init.constant_(self.input_proj.bias, 0) + else: + self.input_proj = nn.Sequential() + + + def forward(self, img_features, encode_feat): + pos = self.pe_layer(encode_feat) + src = encode_feat + mask = None + hs, memory = self.transformer(self.input_proj(src), mask, self.query_embed.weight, pos) + color_embed = hs[-1] + color_preds = torch.einsum('bqc,bchw->bqhw', color_embed, img_features) + return color_preds + diff --git a/basicsr/archs/ddcolor_arch_utils/__int__.py b/basicsr/archs/ddcolor_arch_utils/__int__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/basicsr/archs/ddcolor_arch_utils/convnext.py b/basicsr/archs/ddcolor_arch_utils/convnext.py new file mode 100644 index 0000000000000000000000000000000000000000..e44fd6bec4d98bbb713d13df493ce75d6f2e6da6 --- /dev/null +++ b/basicsr/archs/ddcolor_arch_utils/convnext.py @@ -0,0 +1,155 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. + +# All rights reserved. + +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + + +import torch +import torch.nn as nn +import torch.nn.functional as F +from timm.models.layers import trunc_normal_, DropPath + +class Block(nn.Module): + r""" ConvNeXt Block. There are two equivalent implementations: + (1) DwConv -> LayerNorm (channels_first) -> 1x1 Conv -> GELU -> 1x1 Conv; all in (N, C, H, W) + (2) DwConv -> Permute to (N, H, W, C); LayerNorm (channels_last) -> Linear -> GELU -> Linear; Permute back + We use (2) as we find it slightly faster in PyTorch + + Args: + dim (int): Number of input channels. + drop_path (float): Stochastic depth rate. Default: 0.0 + layer_scale_init_value (float): Init value for Layer Scale. Default: 1e-6. + """ + def __init__(self, dim, drop_path=0., layer_scale_init_value=1e-6): + super().__init__() + self.dwconv = nn.Conv2d(dim, dim, kernel_size=7, padding=3, groups=dim) # depthwise conv + self.norm = LayerNorm(dim, eps=1e-6) + self.pwconv1 = nn.Linear(dim, 4 * dim) # pointwise/1x1 convs, implemented with linear layers + self.act = nn.GELU() + self.pwconv2 = nn.Linear(4 * dim, dim) + self.gamma = nn.Parameter(layer_scale_init_value * torch.ones((dim)), + requires_grad=True) if layer_scale_init_value > 0 else None + self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity() + + def forward(self, x): + input = x + x = self.dwconv(x) + x = x.permute(0, 2, 3, 1) # (N, C, H, W) -> (N, H, W, C) + x = self.norm(x) + x = self.pwconv1(x) + x = self.act(x) + x = self.pwconv2(x) + if self.gamma is not None: + x = self.gamma * x + x = x.permute(0, 3, 1, 2) # (N, H, W, C) -> (N, C, H, W) + + x = input + self.drop_path(x) + return x + +class ConvNeXt(nn.Module): + r""" ConvNeXt + A PyTorch impl of : `A ConvNet for the 2020s` - + https://arxiv.org/pdf/2201.03545.pdf + Args: + in_chans (int): Number of input image channels. Default: 3 + num_classes (int): Number of classes for classification head. Default: 1000 + depths (tuple(int)): Number of blocks at each stage. Default: [3, 3, 9, 3] + dims (int): Feature dimension at each stage. Default: [96, 192, 384, 768] + drop_path_rate (float): Stochastic depth rate. Default: 0. + layer_scale_init_value (float): Init value for Layer Scale. Default: 1e-6. + head_init_scale (float): Init scaling value for classifier weights and biases. Default: 1. + """ + def __init__(self, in_chans=3, num_classes=1000, + depths=[3, 3, 9, 3], dims=[96, 192, 384, 768], drop_path_rate=0., + layer_scale_init_value=1e-6, head_init_scale=1., + ): + super().__init__() + + self.downsample_layers = nn.ModuleList() # stem and 3 intermediate downsampling conv layers + stem = nn.Sequential( + nn.Conv2d(in_chans, dims[0], kernel_size=4, stride=4), + LayerNorm(dims[0], eps=1e-6, data_format="channels_first") + ) + self.downsample_layers.append(stem) + for i in range(3): + downsample_layer = nn.Sequential( + LayerNorm(dims[i], eps=1e-6, data_format="channels_first"), + nn.Conv2d(dims[i], dims[i+1], kernel_size=2, stride=2), + ) + self.downsample_layers.append(downsample_layer) + + self.stages = nn.ModuleList() # 4 feature resolution stages, each consisting of multiple residual blocks + dp_rates=[x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))] + cur = 0 + for i in range(4): + stage = nn.Sequential( + *[Block(dim=dims[i], drop_path=dp_rates[cur + j], + layer_scale_init_value=layer_scale_init_value) for j in range(depths[i])] + ) + self.stages.append(stage) + cur += depths[i] + + # add norm layers for each output + out_indices = (0, 1, 2, 3) + for i in out_indices: + layer = LayerNorm(dims[i], eps=1e-6, data_format="channels_first") + # layer = nn.Identity() + layer_name = f'norm{i}' + self.add_module(layer_name, layer) + + self.norm = nn.LayerNorm(dims[-1], eps=1e-6) # final norm layer + # self.head_cls = nn.Linear(dims[-1], 4) + + self.apply(self._init_weights) + # self.head_cls.weight.data.mul_(head_init_scale) + # self.head_cls.bias.data.mul_(head_init_scale) + + def _init_weights(self, m): + if isinstance(m, (nn.Conv2d, nn.Linear)): + trunc_normal_(m.weight, std=.02) + nn.init.constant_(m.bias, 0) + + def forward_features(self, x): + for i in range(4): + x = self.downsample_layers[i](x) + x = self.stages[i](x) + + # add extra norm + norm_layer = getattr(self, f'norm{i}') + # x = norm_layer(x) + norm_layer(x) + + return self.norm(x.mean([-2, -1])) # global average pooling, (N, C, H, W) -> (N, C) + + def forward(self, x): + x = self.forward_features(x) + # x = self.head_cls(x) + return x + +class LayerNorm(nn.Module): + r""" LayerNorm that supports two data formats: channels_last (default) or channels_first. + The ordering of the dimensions in the inputs. channels_last corresponds to inputs with + shape (batch_size, height, width, channels) while channels_first corresponds to inputs + with shape (batch_size, channels, height, width). + """ + def __init__(self, normalized_shape, eps=1e-6, data_format="channels_last"): + super().__init__() + self.weight = nn.Parameter(torch.ones(normalized_shape)) + self.bias = nn.Parameter(torch.zeros(normalized_shape)) + self.eps = eps + self.data_format = data_format + if self.data_format not in ["channels_last", "channels_first"]: + raise NotImplementedError + self.normalized_shape = (normalized_shape, ) + + def forward(self, x): + if self.data_format == "channels_last": # B H W C + return F.layer_norm(x, self.normalized_shape, self.weight, self.bias, self.eps) + elif self.data_format == "channels_first": # B C H W + u = x.mean(1, keepdim=True) + s = (x - u).pow(2).mean(1, keepdim=True) + x = (x - u) / torch.sqrt(s + self.eps) + x = self.weight[:, None, None] * x + self.bias[:, None, None] + return x diff --git a/basicsr/archs/ddcolor_arch_utils/position_encoding.py b/basicsr/archs/ddcolor_arch_utils/position_encoding.py new file mode 100644 index 0000000000000000000000000000000000000000..9fa7b9e0d0d103596d5cae16dfb578a5de8b45c5 --- /dev/null +++ b/basicsr/archs/ddcolor_arch_utils/position_encoding.py @@ -0,0 +1,52 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# Modified from: https://github.com/facebookresearch/detr/blob/master/models/position_encoding.py +""" +Various positional encodings for the transformer. +""" +import math + +import torch +from torch import nn + + +class PositionEmbeddingSine(nn.Module): + """ + This is a more standard version of the position embedding, very similar to the one + used by the Attention is all you need paper, generalized to work on images. + """ + + def __init__(self, num_pos_feats=64, temperature=10000, normalize=False, scale=None): + super().__init__() + self.num_pos_feats = num_pos_feats + self.temperature = temperature + self.normalize = normalize + if scale is not None and normalize is False: + raise ValueError("normalize should be True if scale is passed") + if scale is None: + scale = 2 * math.pi + self.scale = scale + + def forward(self, x, mask=None): + if mask is None: + mask = torch.zeros((x.size(0), x.size(2), x.size(3)), device=x.device, dtype=torch.bool) + not_mask = ~mask + y_embed = not_mask.cumsum(1, dtype=torch.float32) + x_embed = not_mask.cumsum(2, dtype=torch.float32) + if self.normalize: + eps = 1e-6 + y_embed = y_embed / (y_embed[:, -1:, :] + eps) * self.scale + x_embed = x_embed / (x_embed[:, :, -1:] + eps) * self.scale + + dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device) + dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats) + + pos_x = x_embed[:, :, :, None] / dim_t + pos_y = y_embed[:, :, :, None] / dim_t + pos_x = torch.stack( + (pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4 + ).flatten(3) + pos_y = torch.stack( + (pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4 + ).flatten(3) + pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2) + return pos \ No newline at end of file diff --git a/basicsr/archs/ddcolor_arch_utils/transformer.py b/basicsr/archs/ddcolor_arch_utils/transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..f462a10e34a0578304270538524192bbe63e9fde --- /dev/null +++ b/basicsr/archs/ddcolor_arch_utils/transformer.py @@ -0,0 +1,368 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# Modified from: https://github.com/facebookresearch/detr/blob/master/models/transformer.py +""" +Transformer class. +Copy-paste from torch.nn.Transformer with modifications: + * positional encodings are passed in MHattention + * extra LN at the end of encoder is removed + * decoder returns a stack of activations from all decoding layers +""" +import copy +from typing import List, Optional + +import torch +import torch.nn.functional as F +from torch import Tensor, nn + + +class Transformer(nn.Module): + def __init__( + self, + d_model=512, + nhead=8, + num_encoder_layers=6, + num_decoder_layers=6, + dim_feedforward=2048, + dropout=0.1, + activation="relu", + normalize_before=False, + return_intermediate_dec=False, + ): + super().__init__() + + encoder_layer = TransformerEncoderLayer( + d_model, nhead, dim_feedforward, dropout, activation, normalize_before + ) + encoder_norm = nn.LayerNorm(d_model) if normalize_before else None + self.encoder = TransformerEncoder(encoder_layer, num_encoder_layers, encoder_norm) + + decoder_layer = TransformerDecoderLayer( + d_model, nhead, dim_feedforward, dropout, activation, normalize_before + ) + decoder_norm = nn.LayerNorm(d_model) + self.decoder = TransformerDecoder( + decoder_layer, + num_decoder_layers, + decoder_norm, + return_intermediate=return_intermediate_dec, + ) + + self._reset_parameters() + + self.d_model = d_model + self.nhead = nhead + + def _reset_parameters(self): + for p in self.parameters(): + if p.dim() > 1: + nn.init.xavier_uniform_(p) + + def forward(self, src, mask, query_embed, pos_embed): + # flatten NxCxHxW to HWxNxC + bs, c, h, w = src.shape + src = src.flatten(2).permute(2, 0, 1) + pos_embed = pos_embed.flatten(2).permute(2, 0, 1) + query_embed = query_embed.unsqueeze(1).repeat(1, bs, 1) + if mask is not None: + mask = mask.flatten(1) + + tgt = torch.zeros_like(query_embed) + memory = self.encoder(src, src_key_padding_mask=mask, pos=pos_embed) + hs = self.decoder( + tgt, memory, memory_key_padding_mask=mask, pos=pos_embed, query_pos=query_embed + ) + return hs.transpose(1, 2), memory.permute(1, 2, 0).view(bs, c, h, w) + + +class TransformerEncoder(nn.Module): + def __init__(self, encoder_layer, num_layers, norm=None): + super().__init__() + self.layers = _get_clones(encoder_layer, num_layers) + self.num_layers = num_layers + self.norm = norm + + def forward( + self, + src, + mask: Optional[Tensor] = None, + src_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + ): + output = src + + for layer in self.layers: + output = layer( + output, src_mask=mask, src_key_padding_mask=src_key_padding_mask, pos=pos + ) + + if self.norm is not None: + output = self.norm(output) + + return output + + +class TransformerDecoder(nn.Module): + def __init__(self, decoder_layer, num_layers, norm=None, return_intermediate=False): + super().__init__() + self.layers = _get_clones(decoder_layer, num_layers) + self.num_layers = num_layers + self.norm = norm + self.return_intermediate = return_intermediate + + def forward( + self, + tgt, + memory, + tgt_mask: Optional[Tensor] = None, + memory_mask: Optional[Tensor] = None, + tgt_key_padding_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None, + ): + output = tgt + + intermediate = [] + + for layer in self.layers: + output = layer( + output, + memory, + tgt_mask=tgt_mask, + memory_mask=memory_mask, + tgt_key_padding_mask=tgt_key_padding_mask, + memory_key_padding_mask=memory_key_padding_mask, + pos=pos, + query_pos=query_pos, + ) + if self.return_intermediate: + intermediate.append(self.norm(output)) + + if self.norm is not None: + output = self.norm(output) + if self.return_intermediate: + intermediate.pop() + intermediate.append(output) + + if self.return_intermediate: + return torch.stack(intermediate) + + return output.unsqueeze(0) + + +class TransformerEncoderLayer(nn.Module): + def __init__( + self, + d_model, + nhead, + dim_feedforward=2048, + dropout=0.1, + activation="relu", + normalize_before=False, + ): + super().__init__() + self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout) + # Implementation of Feedforward model + self.linear1 = nn.Linear(d_model, dim_feedforward) + self.dropout = nn.Dropout(dropout) + self.linear2 = nn.Linear(dim_feedforward, d_model) + + self.norm1 = nn.LayerNorm(d_model) + self.norm2 = nn.LayerNorm(d_model) + self.dropout1 = nn.Dropout(dropout) + self.dropout2 = nn.Dropout(dropout) + + self.activation = _get_activation_fn(activation) + self.normalize_before = normalize_before + + def with_pos_embed(self, tensor, pos: Optional[Tensor]): + return tensor if pos is None else tensor + pos + + def forward_post( + self, + src, + src_mask: Optional[Tensor] = None, + src_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + ): + q = k = self.with_pos_embed(src, pos) + src2 = self.self_attn( + q, k, value=src, attn_mask=src_mask, key_padding_mask=src_key_padding_mask + )[0] + src = src + self.dropout1(src2) + src = self.norm1(src) + src2 = self.linear2(self.dropout(self.activation(self.linear1(src)))) + src = src + self.dropout2(src2) + src = self.norm2(src) + return src + + def forward_pre( + self, + src, + src_mask: Optional[Tensor] = None, + src_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + ): + src2 = self.norm1(src) + q = k = self.with_pos_embed(src2, pos) + src2 = self.self_attn( + q, k, value=src2, attn_mask=src_mask, key_padding_mask=src_key_padding_mask + )[0] + src = src + self.dropout1(src2) + src2 = self.norm2(src) + src2 = self.linear2(self.dropout(self.activation(self.linear1(src2)))) + src = src + self.dropout2(src2) + return src + + def forward( + self, + src, + src_mask: Optional[Tensor] = None, + src_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + ): + if self.normalize_before: + return self.forward_pre(src, src_mask, src_key_padding_mask, pos) + return self.forward_post(src, src_mask, src_key_padding_mask, pos) + + +class TransformerDecoderLayer(nn.Module): + def __init__( + self, + d_model, + nhead, + dim_feedforward=2048, + dropout=0.1, + activation="relu", + normalize_before=False, + ): + super().__init__() + self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout) + self.multihead_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout) + # Implementation of Feedforward model + self.linear1 = nn.Linear(d_model, dim_feedforward) + self.dropout = nn.Dropout(dropout) + self.linear2 = nn.Linear(dim_feedforward, d_model) + + self.norm1 = nn.LayerNorm(d_model) + self.norm2 = nn.LayerNorm(d_model) + self.norm3 = nn.LayerNorm(d_model) + self.dropout1 = nn.Dropout(dropout) + self.dropout2 = nn.Dropout(dropout) + self.dropout3 = nn.Dropout(dropout) + + self.activation = _get_activation_fn(activation) + self.normalize_before = normalize_before + + def with_pos_embed(self, tensor, pos: Optional[Tensor]): + return tensor if pos is None else tensor + pos + + def forward_post( + self, + tgt, + memory, + tgt_mask: Optional[Tensor] = None, + memory_mask: Optional[Tensor] = None, + tgt_key_padding_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None, + ): + q = k = self.with_pos_embed(tgt, query_pos) + tgt2 = self.self_attn( + q, k, value=tgt, attn_mask=tgt_mask, key_padding_mask=tgt_key_padding_mask + )[0] + tgt = tgt + self.dropout1(tgt2) + tgt = self.norm1(tgt) + tgt2 = self.multihead_attn( + query=self.with_pos_embed(tgt, query_pos), + key=self.with_pos_embed(memory, pos), + value=memory, + attn_mask=memory_mask, + key_padding_mask=memory_key_padding_mask, + )[0] + tgt = tgt + self.dropout2(tgt2) + tgt = self.norm2(tgt) + tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt)))) + tgt = tgt + self.dropout3(tgt2) + tgt = self.norm3(tgt) + return tgt + + def forward_pre( + self, + tgt, + memory, + tgt_mask: Optional[Tensor] = None, + memory_mask: Optional[Tensor] = None, + tgt_key_padding_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None, + ): + tgt2 = self.norm1(tgt) + q = k = self.with_pos_embed(tgt2, query_pos) + tgt2 = self.self_attn( + q, k, value=tgt2, attn_mask=tgt_mask, key_padding_mask=tgt_key_padding_mask + )[0] + tgt = tgt + self.dropout1(tgt2) + tgt2 = self.norm2(tgt) + tgt2 = self.multihead_attn( + query=self.with_pos_embed(tgt2, query_pos), + key=self.with_pos_embed(memory, pos), + value=memory, + attn_mask=memory_mask, + key_padding_mask=memory_key_padding_mask, + )[0] + tgt = tgt + self.dropout2(tgt2) + tgt2 = self.norm3(tgt) + tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt2)))) + tgt = tgt + self.dropout3(tgt2) + return tgt + + def forward( + self, + tgt, + memory, + tgt_mask: Optional[Tensor] = None, + memory_mask: Optional[Tensor] = None, + tgt_key_padding_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None, + ): + if self.normalize_before: + return self.forward_pre( + tgt, + memory, + tgt_mask, + memory_mask, + tgt_key_padding_mask, + memory_key_padding_mask, + pos, + query_pos, + ) + return self.forward_post( + tgt, + memory, + tgt_mask, + memory_mask, + tgt_key_padding_mask, + memory_key_padding_mask, + pos, + query_pos, + ) + + +def _get_clones(module, N): + return nn.ModuleList([copy.deepcopy(module) for i in range(N)]) + + +def _get_activation_fn(activation): + """Return an activation function given a string""" + if activation == "relu": + return F.relu + if activation == "gelu": + return F.gelu + if activation == "glu": + return F.glu + raise RuntimeError(f"activation should be relu/gelu, not {activation}.") \ No newline at end of file diff --git a/basicsr/archs/ddcolor_arch_utils/transformer_utils.py b/basicsr/archs/ddcolor_arch_utils/transformer_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..ea38f399d541ccbc25999fb14201cfcffa3d8f8a --- /dev/null +++ b/basicsr/archs/ddcolor_arch_utils/transformer_utils.py @@ -0,0 +1,192 @@ +from typing import Optional +from torch import nn, Tensor +from torch.nn import functional as F + +class SelfAttentionLayer(nn.Module): + + def __init__(self, d_model, nhead, dropout=0.0, + activation="relu", normalize_before=False): + super().__init__() + self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout) + + self.norm = nn.LayerNorm(d_model) + self.dropout = nn.Dropout(dropout) + + self.activation = _get_activation_fn(activation) + self.normalize_before = normalize_before + + self._reset_parameters() + + def _reset_parameters(self): + for p in self.parameters(): + if p.dim() > 1: + nn.init.xavier_uniform_(p) + + def with_pos_embed(self, tensor, pos: Optional[Tensor]): + return tensor if pos is None else tensor + pos + + def forward_post(self, tgt, + tgt_mask: Optional[Tensor] = None, + tgt_key_padding_mask: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None): + q = k = self.with_pos_embed(tgt, query_pos) + tgt2 = self.self_attn(q, k, value=tgt, attn_mask=tgt_mask, + key_padding_mask=tgt_key_padding_mask)[0] + tgt = tgt + self.dropout(tgt2) + tgt = self.norm(tgt) + + return tgt + + def forward_pre(self, tgt, + tgt_mask: Optional[Tensor] = None, + tgt_key_padding_mask: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None): + tgt2 = self.norm(tgt) + q = k = self.with_pos_embed(tgt2, query_pos) + tgt2 = self.self_attn(q, k, value=tgt2, attn_mask=tgt_mask, + key_padding_mask=tgt_key_padding_mask)[0] + tgt = tgt + self.dropout(tgt2) + + return tgt + + def forward(self, tgt, + tgt_mask: Optional[Tensor] = None, + tgt_key_padding_mask: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None): + if self.normalize_before: + return self.forward_pre(tgt, tgt_mask, + tgt_key_padding_mask, query_pos) + return self.forward_post(tgt, tgt_mask, + tgt_key_padding_mask, query_pos) + + +class CrossAttentionLayer(nn.Module): + + def __init__(self, d_model, nhead, dropout=0.0, + activation="relu", normalize_before=False): + super().__init__() + self.multihead_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout) + + self.norm = nn.LayerNorm(d_model) + self.dropout = nn.Dropout(dropout) + + self.activation = _get_activation_fn(activation) + self.normalize_before = normalize_before + + self._reset_parameters() + + def _reset_parameters(self): + for p in self.parameters(): + if p.dim() > 1: + nn.init.xavier_uniform_(p) + + def with_pos_embed(self, tensor, pos: Optional[Tensor]): + return tensor if pos is None else tensor + pos + + def forward_post(self, tgt, memory, + memory_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None): + tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt, query_pos), + key=self.with_pos_embed(memory, pos), + value=memory, attn_mask=memory_mask, + key_padding_mask=memory_key_padding_mask)[0] + tgt = tgt + self.dropout(tgt2) + tgt = self.norm(tgt) + + return tgt + + def forward_pre(self, tgt, memory, + memory_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None): + tgt2 = self.norm(tgt) + tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt2, query_pos), + key=self.with_pos_embed(memory, pos), + value=memory, attn_mask=memory_mask, + key_padding_mask=memory_key_padding_mask)[0] + tgt = tgt + self.dropout(tgt2) + + return tgt + + def forward(self, tgt, memory, + memory_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None): + if self.normalize_before: + return self.forward_pre(tgt, memory, memory_mask, + memory_key_padding_mask, pos, query_pos) + return self.forward_post(tgt, memory, memory_mask, + memory_key_padding_mask, pos, query_pos) + + +class FFNLayer(nn.Module): + + def __init__(self, d_model, dim_feedforward=2048, dropout=0.0, + activation="relu", normalize_before=False): + super().__init__() + # Implementation of Feedforward model + self.linear1 = nn.Linear(d_model, dim_feedforward) + self.dropout = nn.Dropout(dropout) + self.linear2 = nn.Linear(dim_feedforward, d_model) + + self.norm = nn.LayerNorm(d_model) + + self.activation = _get_activation_fn(activation) + self.normalize_before = normalize_before + + self._reset_parameters() + + def _reset_parameters(self): + for p in self.parameters(): + if p.dim() > 1: + nn.init.xavier_uniform_(p) + + def with_pos_embed(self, tensor, pos: Optional[Tensor]): + return tensor if pos is None else tensor + pos + + def forward_post(self, tgt): + tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt)))) + tgt = tgt + self.dropout(tgt2) + tgt = self.norm(tgt) + return tgt + + def forward_pre(self, tgt): + tgt2 = self.norm(tgt) + tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt2)))) + tgt = tgt + self.dropout(tgt2) + return tgt + + def forward(self, tgt): + if self.normalize_before: + return self.forward_pre(tgt) + return self.forward_post(tgt) + + +def _get_activation_fn(activation): + """Return an activation function given a string""" + if activation == "relu": + return F.relu + if activation == "gelu": + return F.gelu + if activation == "glu": + return F.glu + raise RuntimeError(F"activation should be relu/gelu, not {activation}.") + + +class MLP(nn.Module): + """ Very simple multi-layer perceptron (also called FFN)""" + + def __init__(self, input_dim, hidden_dim, output_dim, num_layers): + super().__init__() + self.num_layers = num_layers + h = [hidden_dim] * (num_layers - 1) + self.layers = nn.ModuleList(nn.Linear(n, k) for n, k in zip([input_dim] + h, h + [output_dim])) + + def forward(self, x): + for i, layer in enumerate(self.layers): + x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x) + return x \ No newline at end of file diff --git a/basicsr/archs/ddcolor_arch_utils/unet.py b/basicsr/archs/ddcolor_arch_utils/unet.py new file mode 100644 index 0000000000000000000000000000000000000000..4610ba589242266383ba1b7cddca12c653b97daa --- /dev/null +++ b/basicsr/archs/ddcolor_arch_utils/unet.py @@ -0,0 +1,208 @@ +from enum import Enum +import torch +import torch.nn as nn +from torch.nn import functional as F +import collections + + +NormType = Enum('NormType', 'Batch BatchZero Weight Spectral') + + +class Hook: + feature = None + + def __init__(self, module): + self.hook = module.register_forward_hook(self.hook_fn) + + def hook_fn(self, module, input, output): + if isinstance(output, torch.Tensor): + self.feature = output + elif isinstance(output, collections.OrderedDict): + self.feature = output['out'] + + def remove(self): + self.hook.remove() + + +class SelfAttention(nn.Module): + "Self attention layer for nd." + + def __init__(self, n_channels: int): + super().__init__() + self.query = conv1d(n_channels, n_channels // 8) + self.key = conv1d(n_channels, n_channels // 8) + self.value = conv1d(n_channels, n_channels) + self.gamma = nn.Parameter(torch.tensor([0.])) + + def forward(self, x): + #Notation from https://arxiv.org/pdf/1805.08318.pdf + size = x.size() + x = x.view(*size[:2], -1) + f, g, h = self.query(x), self.key(x), self.value(x) + beta = F.softmax(torch.bmm(f.permute(0, 2, 1).contiguous(), g), dim=1) + o = self.gamma * torch.bmm(h, beta) + x + return o.view(*size).contiguous() + + +def batchnorm_2d(nf: int, norm_type: NormType = NormType.Batch): + "A batchnorm2d layer with `nf` features initialized depending on `norm_type`." + bn = nn.BatchNorm2d(nf) + with torch.no_grad(): + bn.bias.fill_(1e-3) + bn.weight.fill_(0. if norm_type == NormType.BatchZero else 1.) + return bn + + +def init_default(m: nn.Module, func=nn.init.kaiming_normal_) -> None: + "Initialize `m` weights with `func` and set `bias` to 0." + if func: + if hasattr(m, 'weight'): func(m.weight) + if hasattr(m, 'bias') and hasattr(m.bias, 'data'): m.bias.data.fill_(0.) + return m + + +def icnr(x, scale=2, init=nn.init.kaiming_normal_): + "ICNR init of `x`, with `scale` and `init` function." + ni, nf, h, w = x.shape + ni2 = int(ni / (scale**2)) + k = init(torch.zeros([ni2, nf, h, w])).transpose(0, 1) + k = k.contiguous().view(ni2, nf, -1) + k = k.repeat(1, 1, scale**2) + k = k.contiguous().view([nf, ni, h, w]).transpose(0, 1) + x.data.copy_(k) + + +def conv1d(ni: int, no: int, ks: int = 1, stride: int = 1, padding: int = 0, bias: bool = False): + "Create and initialize a `nn.Conv1d` layer with spectral normalization." + conv = nn.Conv1d(ni, no, ks, stride=stride, padding=padding, bias=bias) + nn.init.kaiming_normal_(conv.weight) + if bias: conv.bias.data.zero_() + return nn.utils.spectral_norm(conv) + + +def custom_conv_layer( + ni: int, + nf: int, + ks: int = 3, + stride: int = 1, + padding: int = None, + bias: bool = None, + is_1d: bool = False, + norm_type=NormType.Batch, + use_activ: bool = True, + transpose: bool = False, + init=nn.init.kaiming_normal_, + self_attention: bool = False, + extra_bn: bool = False, +): + "Create a sequence of convolutional (`ni` to `nf`), ReLU (if `use_activ`) and batchnorm (if `bn`) layers." + if padding is None: + padding = (ks - 1) // 2 if not transpose else 0 + bn = norm_type in (NormType.Batch, NormType.BatchZero) or extra_bn == True + if bias is None: + bias = not bn + conv_func = nn.ConvTranspose2d if transpose else nn.Conv1d if is_1d else nn.Conv2d + conv = init_default( + conv_func(ni, nf, kernel_size=ks, bias=bias, stride=stride, padding=padding), + init, + ) + + if norm_type == NormType.Weight: + conv = nn.utils.weight_norm(conv) + elif norm_type == NormType.Spectral: + conv = nn.utils.spectral_norm(conv) + layers = [conv] + if use_activ: + layers.append(nn.ReLU(True)) + if bn: + layers.append((nn.BatchNorm1d if is_1d else nn.BatchNorm2d)(nf)) + if self_attention: + layers.append(SelfAttention(nf)) + return nn.Sequential(*layers) + + +def conv_layer(ni: int, + nf: int, + ks: int = 3, + stride: int = 1, + padding: int = None, + bias: bool = None, + is_1d: bool = False, + norm_type=NormType.Batch, + use_activ: bool = True, + transpose: bool = False, + init=nn.init.kaiming_normal_, + self_attention: bool = False): + "Create a sequence of convolutional (`ni` to `nf`), ReLU (if `use_activ`) and batchnorm (if `bn`) layers." + if padding is None: padding = (ks - 1) // 2 if not transpose else 0 + bn = norm_type in (NormType.Batch, NormType.BatchZero) + if bias is None: bias = not bn + conv_func = nn.ConvTranspose2d if transpose else nn.Conv1d if is_1d else nn.Conv2d + conv = init_default(conv_func(ni, nf, kernel_size=ks, bias=bias, stride=stride, padding=padding), init) + if norm_type == NormType.Weight: conv = nn.utils.weight_norm(conv) + elif norm_type == NormType.Spectral: conv = nn.utils.spectral_norm(conv) + layers = [conv] + if use_activ: layers.append(nn.ReLU(True)) + if bn: layers.append((nn.BatchNorm1d if is_1d else nn.BatchNorm2d)(nf)) + if self_attention: layers.append(SelfAttention(nf)) + return nn.Sequential(*layers) + + +def _conv(ni: int, nf: int, ks: int = 3, stride: int = 1, **kwargs): + return conv_layer(ni, nf, ks=ks, stride=stride, norm_type=NormType.Spectral, **kwargs) + + +class CustomPixelShuffle_ICNR(nn.Module): + "Upsample by `scale` from `ni` filters to `nf` (default `ni`), using `nn.PixelShuffle`, `icnr` init, and `weight_norm`." + + def __init__(self, + ni: int, + nf: int = None, + scale: int = 2, + blur: bool = True, + norm_type=NormType.Spectral, + extra_bn=False): + super().__init__() + self.conv = custom_conv_layer( + ni, nf * (scale**2), ks=1, use_activ=False, norm_type=norm_type, extra_bn=extra_bn) + icnr(self.conv[0].weight) + self.shuf = nn.PixelShuffle(scale) + self.do_blur = blur + # Blurring over (h*w) kernel + # "Super-Resolution using Convolutional Neural Networks without Any Checkerboard Artifacts" + # - https://arxiv.org/abs/1806.02658 + self.pad = nn.ReplicationPad2d((1, 0, 1, 0)) + self.blur = nn.AvgPool2d(2, stride=1) + self.relu = nn.ReLU(True) + + def forward(self, x): + x = self.shuf(self.relu(self.conv(x))) + return self.blur(self.pad(x)) if self.do_blur else x + + +class UnetBlockWide(nn.Module): + "A quasi-UNet block, using `PixelShuffle_ICNR upsampling`." + + def __init__(self, + up_in_c: int, + x_in_c: int, + n_out: int, + hook, + blur: bool = False, + self_attention: bool = False, + norm_type=NormType.Spectral): + super().__init__() + + self.hook = hook + up_out = n_out + self.shuf = CustomPixelShuffle_ICNR(up_in_c, up_out, blur=blur, norm_type=norm_type, extra_bn=True) + self.bn = batchnorm_2d(x_in_c) + ni = up_out + x_in_c + self.conv = custom_conv_layer(ni, n_out, norm_type=norm_type, self_attention=self_attention, extra_bn=True) + self.relu = nn.ReLU() + + def forward(self, up_in): + s = self.hook.feature + up_out = self.shuf(up_in) + cat_x = self.relu(torch.cat([up_out, self.bn(s)], dim=1)) + return self.conv(cat_x) diff --git a/basicsr/archs/ddcolor_arch_utils/util.py b/basicsr/archs/ddcolor_arch_utils/util.py new file mode 100644 index 0000000000000000000000000000000000000000..c7226d8af6b66f8873b0cc8d7035692061118ec3 --- /dev/null +++ b/basicsr/archs/ddcolor_arch_utils/util.py @@ -0,0 +1,63 @@ +import numpy as np +import torch +from skimage import color + + +def rgb2lab(img_rgb): + img_lab = color.rgb2lab(img_rgb) + return img_lab[:, :, :1], img_lab[:, :, 1:] + + +def tensor_lab2rgb(labs, illuminant="D65", observer="2"): + """ + Args: + lab : (B, C, H, W) + Returns: + tuple : (B, C, H, W) + """ + illuminants = \ + {"A": {'2': (1.098466069456375, 1, 0.3558228003436005), + '10': (1.111420406956693, 1, 0.3519978321919493)}, + "D50": {'2': (0.9642119944211994, 1, 0.8251882845188288), + '10': (0.9672062750333777, 1, 0.8142801513128616)}, + "D55": {'2': (0.956797052643698, 1, 0.9214805860173273), + '10': (0.9579665682254781, 1, 0.9092525159847462)}, + "D65": {'2': (0.95047, 1., 1.08883), # This was: `lab_ref_white` + '10': (0.94809667673716, 1, 1.0730513595166162)}, + "D75": {'2': (0.9497220898840717, 1, 1.226393520724154), + '10': (0.9441713925645873, 1, 1.2064272211720228)}, + "E": {'2': (1.0, 1.0, 1.0), + '10': (1.0, 1.0, 1.0)}} + xyz_from_rgb = np.array([[0.412453, 0.357580, 0.180423], [0.212671, 0.715160, 0.072169], + [0.019334, 0.119193, 0.950227]]) + + rgb_from_xyz = np.array([[3.240481340, -0.96925495, 0.055646640], [-1.53715152, 1.875990000, -0.20404134], + [-0.49853633, 0.041555930, 1.057311070]]) + B, C, H, W = labs.shape + arrs = labs.permute((0, 2, 3, 1)).contiguous() # (B, 3, H, W) -> (B, H, W, 3) + L, a, b = arrs[:, :, :, 0:1], arrs[:, :, :, 1:2], arrs[:, :, :, 2:] + y = (L + 16.) / 116. + x = (a / 500.) + y + z = y - (b / 200.) + invalid = z.data < 0 + z[invalid] = 0 + xyz = torch.cat([x, y, z], dim=3) + mask = xyz.data > 0.2068966 + mask_xyz = xyz.clone() + mask_xyz[mask] = torch.pow(xyz[mask], 3.0) + mask_xyz[~mask] = (xyz[~mask] - 16.0 / 116.) / 7.787 + xyz_ref_white = illuminants[illuminant][observer] + for i in range(C): + mask_xyz[:, :, :, i] = mask_xyz[:, :, :, i] * xyz_ref_white[i] + + rgb_trans = torch.mm(mask_xyz.view(-1, 3), torch.from_numpy(rgb_from_xyz).type_as(xyz)).view(B, H, W, C) + rgb = rgb_trans.permute((0, 3, 1, 2)).contiguous() + mask = rgb.data > 0.0031308 + mask_rgb = rgb.clone() + mask_rgb[mask] = 1.055 * torch.pow(rgb[mask], 1 / 2.4) - 0.055 + mask_rgb[~mask] = rgb[~mask] * 12.92 + neg_mask = mask_rgb.data < 0 + large_mask = mask_rgb.data > 1 + mask_rgb[neg_mask] = 0 + mask_rgb[large_mask] = 1 + return mask_rgb \ No newline at end of file diff --git a/basicsr/archs/discriminator_arch.py b/basicsr/archs/discriminator_arch.py new file mode 100644 index 0000000000000000000000000000000000000000..a3784102f02a430f717fa5678b306926400c885d --- /dev/null +++ b/basicsr/archs/discriminator_arch.py @@ -0,0 +1,28 @@ +import torch +import torch.nn as nn +from torchvision import models +import numpy as np + +from basicsr.archs.ddcolor_arch_utils.unet import _conv +from basicsr.utils.registry import ARCH_REGISTRY + + +@ARCH_REGISTRY.register() +class DynamicUNetDiscriminator(nn.Module): + + def __init__(self, n_channels: int = 3, nf: int = 256, n_blocks: int = 3): + super().__init__() + layers = [_conv(n_channels, nf, ks=4, stride=2)] + for i in range(n_blocks): + layers += [ + _conv(nf, nf, ks=3, stride=1), + _conv(nf, nf * 2, ks=4, stride=2, self_attention=(i == 0)), + ] + nf *= 2 + layers += [_conv(nf, nf, ks=3, stride=1), _conv(nf, 1, ks=4, bias=False, padding=0, use_activ=False)] + self.layers = nn.Sequential(*layers) + + def forward(self, x): + out = self.layers(x) + out = out.view(out.size(0), -1) + return out diff --git a/basicsr/archs/vgg_arch.py b/basicsr/archs/vgg_arch.py new file mode 100644 index 0000000000000000000000000000000000000000..436d231915e6d6ee5dd71ac21189492f022d6fca --- /dev/null +++ b/basicsr/archs/vgg_arch.py @@ -0,0 +1,165 @@ +import os +import torch +from collections import OrderedDict +from torch import nn as nn +from torchvision.models import vgg as vgg + +from basicsr.utils.registry import ARCH_REGISTRY + +VGG_PRETRAIN_PATH = { + 'vgg19': './pretrain/vgg19-dcbb9e9d.pth', + 'vgg16_bn': './pretrain/vgg16_bn-6c64b313.pth' +} + +NAMES = { + 'vgg11': [ + 'conv1_1', 'relu1_1', 'pool1', 'conv2_1', 'relu2_1', 'pool2', 'conv3_1', 'relu3_1', 'conv3_2', 'relu3_2', + 'pool3', 'conv4_1', 'relu4_1', 'conv4_2', 'relu4_2', 'pool4', 'conv5_1', 'relu5_1', 'conv5_2', 'relu5_2', + 'pool5' + ], + 'vgg13': [ + 'conv1_1', 'relu1_1', 'conv1_2', 'relu1_2', 'pool1', 'conv2_1', 'relu2_1', 'conv2_2', 'relu2_2', 'pool2', + 'conv3_1', 'relu3_1', 'conv3_2', 'relu3_2', 'pool3', 'conv4_1', 'relu4_1', 'conv4_2', 'relu4_2', 'pool4', + 'conv5_1', 'relu5_1', 'conv5_2', 'relu5_2', 'pool5' + ], + 'vgg16': [ + 'conv1_1', 'relu1_1', 'conv1_2', 'relu1_2', 'pool1', 'conv2_1', 'relu2_1', 'conv2_2', 'relu2_2', 'pool2', + 'conv3_1', 'relu3_1', 'conv3_2', 'relu3_2', 'conv3_3', 'relu3_3', 'pool3', 'conv4_1', 'relu4_1', 'conv4_2', + 'relu4_2', 'conv4_3', 'relu4_3', 'pool4', 'conv5_1', 'relu5_1', 'conv5_2', 'relu5_2', 'conv5_3', 'relu5_3', + 'pool5' + ], + 'vgg19': [ + 'conv1_1', 'relu1_1', 'conv1_2', 'relu1_2', 'pool1', 'conv2_1', 'relu2_1', 'conv2_2', 'relu2_2', 'pool2', + 'conv3_1', 'relu3_1', 'conv3_2', 'relu3_2', 'conv3_3', 'relu3_3', 'conv3_4', 'relu3_4', 'pool3', 'conv4_1', + 'relu4_1', 'conv4_2', 'relu4_2', 'conv4_3', 'relu4_3', 'conv4_4', 'relu4_4', 'pool4', 'conv5_1', 'relu5_1', + 'conv5_2', 'relu5_2', 'conv5_3', 'relu5_3', 'conv5_4', 'relu5_4', 'pool5' + ] +} + + +def insert_bn(names): + """Insert bn layer after each conv. + + Args: + names (list): The list of layer names. + + Returns: + list: The list of layer names with bn layers. + """ + names_bn = [] + for name in names: + names_bn.append(name) + if 'conv' in name: + position = name.replace('conv', '') + names_bn.append('bn' + position) + return names_bn + + +@ARCH_REGISTRY.register() +class VGGFeatureExtractor(nn.Module): + """VGG network for feature extraction. + + In this implementation, we allow users to choose whether use normalization + in the input feature and the type of vgg network. Note that the pretrained + path must fit the vgg type. + + Args: + layer_name_list (list[str]): Forward function returns the corresponding + features according to the layer_name_list. + Example: {'relu1_1', 'relu2_1', 'relu3_1'}. + vgg_type (str): Set the type of vgg network. Default: 'vgg19'. + use_input_norm (bool): If True, normalize the input image. Importantly, + the input feature must in the range [0, 1]. Default: True. + range_norm (bool): If True, norm images with range [-1, 1] to [0, 1]. + Default: False. + requires_grad (bool): If true, the parameters of VGG network will be + optimized. Default: False. + remove_pooling (bool): If true, the max pooling operations in VGG net + will be removed. Default: False. + pooling_stride (int): The stride of max pooling operation. Default: 2. + """ + + def __init__(self, + layer_name_list, + vgg_type='vgg19', + use_input_norm=True, + range_norm=False, + requires_grad=False, + remove_pooling=False, + pooling_stride=2): + super(VGGFeatureExtractor, self).__init__() + + self.layer_name_list = layer_name_list + self.use_input_norm = use_input_norm + self.range_norm = range_norm + + self.names = NAMES[vgg_type.replace('_bn', '')] + if 'bn' in vgg_type: + self.names = insert_bn(self.names) + + # only borrow layers that will be used to avoid unused params + max_idx = 0 + for v in layer_name_list: + idx = self.names.index(v) + if idx > max_idx: + max_idx = idx + + if os.path.exists(VGG_PRETRAIN_PATH[vgg_type]): + vgg_net = getattr(vgg, vgg_type)(pretrained=False) + state_dict = torch.load(VGG_PRETRAIN_PATH[vgg_type], map_location=lambda storage, loc: storage) + vgg_net.load_state_dict(state_dict) + else: + vgg_net = getattr(vgg, vgg_type)(pretrained=True) + + features = vgg_net.features[:max_idx + 1] + + modified_net = OrderedDict() + for k, v in zip(self.names, features): + if 'pool' in k: + # if remove_pooling is true, pooling operation will be removed + if remove_pooling: + continue + else: + # in some cases, we may want to change the default stride + modified_net[k] = nn.MaxPool2d(kernel_size=2, stride=pooling_stride) + else: + modified_net[k] = v + + self.vgg_net = nn.Sequential(modified_net) + + if not requires_grad: + self.vgg_net.eval() + for param in self.parameters(): + param.requires_grad = False + else: + self.vgg_net.train() + for param in self.parameters(): + param.requires_grad = True + + if self.use_input_norm: + # the mean is for image with range [0, 1] + self.register_buffer('mean', torch.Tensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1)) + # the std is for image with range [0, 1] + self.register_buffer('std', torch.Tensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1)) + + def forward(self, x): + """Forward function. + + Args: + x (Tensor): Input tensor with shape (n, c, h, w). + + Returns: + Tensor: Forward results. + """ + if self.range_norm: + x = (x + 1) / 2 + if self.use_input_norm: + x = (x - self.mean) / self.std + + output = {} + for key, layer in self.vgg_net._modules.items(): + x = layer(x) + if key in self.layer_name_list: + output[key] = x.clone() + + return output diff --git a/basicsr/data/__init__.py b/basicsr/data/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6aa0af876863ca27daa799ef269a235df784f6ea --- /dev/null +++ b/basicsr/data/__init__.py @@ -0,0 +1,101 @@ +import importlib +import numpy as np +import random +import torch +import torch.utils.data +from copy import deepcopy +from functools import partial +from os import path as osp + +from basicsr.data.prefetch_dataloader import PrefetchDataLoader +from basicsr.utils import get_root_logger, scandir +from basicsr.utils.dist_util import get_dist_info +from basicsr.utils.registry import DATASET_REGISTRY + +__all__ = ['build_dataset', 'build_dataloader'] + +# automatically scan and import dataset modules for registry +# scan all the files under the data folder with '_dataset' in file names +data_folder = osp.dirname(osp.abspath(__file__)) +dataset_filenames = [osp.splitext(osp.basename(v))[0] for v in scandir(data_folder) if v.endswith('_dataset.py')] +# import all the dataset modules +_dataset_modules = [importlib.import_module(f'basicsr.data.{file_name}') for file_name in dataset_filenames] + + +def build_dataset(dataset_opt): + """Build dataset from options. + + Args: + dataset_opt (dict): Configuration for dataset. It must contain: + name (str): Dataset name. + type (str): Dataset type. + """ + dataset_opt = deepcopy(dataset_opt) + dataset = DATASET_REGISTRY.get(dataset_opt['type'])(dataset_opt) + logger = get_root_logger() + logger.info(f'Dataset [{dataset.__class__.__name__}] - {dataset_opt["name"]} ' 'is built.') + return dataset + + +def build_dataloader(dataset, dataset_opt, num_gpu=1, dist=False, sampler=None, seed=None): + """Build dataloader. + + Args: + dataset (torch.utils.data.Dataset): Dataset. + dataset_opt (dict): Dataset options. It contains the following keys: + phase (str): 'train' or 'val'. + num_worker_per_gpu (int): Number of workers for each GPU. + batch_size_per_gpu (int): Training batch size for each GPU. + num_gpu (int): Number of GPUs. Used only in the train phase. + Default: 1. + dist (bool): Whether in distributed training. Used only in the train + phase. Default: False. + sampler (torch.utils.data.sampler): Data sampler. Default: None. + seed (int | None): Seed. Default: None + """ + phase = dataset_opt['phase'] + rank, _ = get_dist_info() + if phase == 'train': + if dist: # distributed training + batch_size = dataset_opt['batch_size_per_gpu'] + num_workers = dataset_opt['num_worker_per_gpu'] + else: # non-distributed training + multiplier = 1 if num_gpu == 0 else num_gpu + batch_size = dataset_opt['batch_size_per_gpu'] * multiplier + num_workers = dataset_opt['num_worker_per_gpu'] * multiplier + dataloader_args = dict( + dataset=dataset, + batch_size=batch_size, + shuffle=False, + num_workers=num_workers, + sampler=sampler, + drop_last=True) + if sampler is None: + dataloader_args['shuffle'] = True + dataloader_args['worker_init_fn'] = partial( + worker_init_fn, num_workers=num_workers, rank=rank, seed=seed) if seed is not None else None + elif phase in ['val', 'test']: # validation + dataloader_args = dict(dataset=dataset, batch_size=1, shuffle=False, num_workers=0) + else: + raise ValueError(f'Wrong dataset phase: {phase}. ' "Supported ones are 'train', 'val' and 'test'.") + + dataloader_args['pin_memory'] = dataset_opt.get('pin_memory', False) + dataloader_args['persistent_workers'] = dataset_opt.get('persistent_workers', False) + + prefetch_mode = dataset_opt.get('prefetch_mode') + if prefetch_mode == 'cpu': # CPUPrefetcher + num_prefetch_queue = dataset_opt.get('num_prefetch_queue', 1) + logger = get_root_logger() + logger.info(f'Use {prefetch_mode} prefetch dataloader: num_prefetch_queue = {num_prefetch_queue}') + return PrefetchDataLoader(num_prefetch_queue=num_prefetch_queue, **dataloader_args) + else: + # prefetch_mode=None: Normal dataloader + # prefetch_mode='cuda': dataloader for CUDAPrefetcher + return torch.utils.data.DataLoader(**dataloader_args) + + +def worker_init_fn(worker_id, num_workers, rank, seed): + # Set the worker seed to num_workers * rank + worker_id + seed + worker_seed = num_workers * rank + worker_id + seed + np.random.seed(worker_seed) + random.seed(worker_seed) diff --git a/basicsr/data/data_sampler.py b/basicsr/data/data_sampler.py new file mode 100644 index 0000000000000000000000000000000000000000..575452d9f844a928f7f42296c81635cfbadec7c2 --- /dev/null +++ b/basicsr/data/data_sampler.py @@ -0,0 +1,48 @@ +import math +import torch +from torch.utils.data.sampler import Sampler + + +class EnlargedSampler(Sampler): + """Sampler that restricts data loading to a subset of the dataset. + + Modified from torch.utils.data.distributed.DistributedSampler + Support enlarging the dataset for iteration-based training, for saving + time when restart the dataloader after each epoch + + Args: + dataset (torch.utils.data.Dataset): Dataset used for sampling. + num_replicas (int | None): Number of processes participating in + the training. It is usually the world_size. + rank (int | None): Rank of the current process within num_replicas. + ratio (int): Enlarging ratio. Default: 1. + """ + + def __init__(self, dataset, num_replicas, rank, ratio=1): + self.dataset = dataset + self.num_replicas = num_replicas + self.rank = rank + self.epoch = 0 + self.num_samples = math.ceil(len(self.dataset) * ratio / self.num_replicas) + self.total_size = self.num_samples * self.num_replicas + + def __iter__(self): + # deterministically shuffle based on epoch + g = torch.Generator() + g.manual_seed(self.epoch) + indices = torch.randperm(self.total_size, generator=g).tolist() + + dataset_size = len(self.dataset) + indices = [v % dataset_size for v in indices] + + # 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): + self.epoch = epoch diff --git a/basicsr/data/data_util.py b/basicsr/data/data_util.py new file mode 100644 index 0000000000000000000000000000000000000000..40db8154c3ca8f447d1eadf218c769a1eb482a04 --- /dev/null +++ b/basicsr/data/data_util.py @@ -0,0 +1,313 @@ +import cv2 +import numpy as np +import torch +from os import path as osp +from torch.nn import functional as F + +from basicsr.data.transforms import mod_crop +from basicsr.utils import img2tensor, scandir + + +def read_img_seq(path, require_mod_crop=False, scale=1, return_imgname=False): + """Read a sequence of images from a given folder path. + + Args: + path (list[str] | str): List of image paths or image folder path. + require_mod_crop (bool): Require mod crop for each image. + Default: False. + scale (int): Scale factor for mod_crop. Default: 1. + return_imgname(bool): Whether return image names. Default False. + + Returns: + Tensor: size (t, c, h, w), RGB, [0, 1]. + list[str]: Returned image name list. + """ + if isinstance(path, list): + img_paths = path + else: + img_paths = sorted(list(scandir(path, full_path=True))) + imgs = [cv2.imread(v).astype(np.float32) / 255. for v in img_paths] + + if require_mod_crop: + imgs = [mod_crop(img, scale) for img in imgs] + imgs = img2tensor(imgs, bgr2rgb=True, float32=True) + imgs = torch.stack(imgs, dim=0) + + if return_imgname: + imgnames = [osp.splitext(osp.basename(path))[0] for path in img_paths] + return imgs, imgnames + else: + return imgs + + +def generate_frame_indices(crt_idx, max_frame_num, num_frames, padding='reflection'): + """Generate an index list for reading `num_frames` frames from a sequence + of images. + + Args: + crt_idx (int): Current center index. + max_frame_num (int): Max number of the sequence of images (from 1). + num_frames (int): Reading num_frames frames. + padding (str): Padding mode, one of + 'replicate' | 'reflection' | 'reflection_circle' | 'circle' + Examples: current_idx = 0, num_frames = 5 + The generated frame indices under different padding mode: + replicate: [0, 0, 0, 1, 2] + reflection: [2, 1, 0, 1, 2] + reflection_circle: [4, 3, 0, 1, 2] + circle: [3, 4, 0, 1, 2] + + Returns: + list[int]: A list of indices. + """ + assert num_frames % 2 == 1, 'num_frames should be an odd number.' + assert padding in ('replicate', 'reflection', 'reflection_circle', 'circle'), f'Wrong padding mode: {padding}.' + + max_frame_num = max_frame_num - 1 # start from 0 + num_pad = num_frames // 2 + + indices = [] + for i in range(crt_idx - num_pad, crt_idx + num_pad + 1): + if i < 0: + if padding == 'replicate': + pad_idx = 0 + elif padding == 'reflection': + pad_idx = -i + elif padding == 'reflection_circle': + pad_idx = crt_idx + num_pad - i + else: + pad_idx = num_frames + i + elif i > max_frame_num: + if padding == 'replicate': + pad_idx = max_frame_num + elif padding == 'reflection': + pad_idx = max_frame_num * 2 - i + elif padding == 'reflection_circle': + pad_idx = (crt_idx - num_pad) - (i - max_frame_num) + else: + pad_idx = i - num_frames + else: + pad_idx = i + indices.append(pad_idx) + return indices + + +def paired_paths_from_lmdb(folders, keys): + """Generate paired paths from lmdb files. + + Contents of lmdb. Taking the `lq.lmdb` for example, the file structure is: + + lq.lmdb + ├── data.mdb + ├── lock.mdb + ├── meta_info.txt + + The data.mdb and lock.mdb are standard lmdb files and you can refer to + https://lmdb.readthedocs.io/en/release/ for more details. + + The meta_info.txt is a specified txt file to record the meta information + of our datasets. It will be automatically created when preparing + datasets by our provided dataset tools. + Each line in the txt file records + 1)image name (with extension), + 2)image shape, + 3)compression level, separated by a white space. + Example: `baboon.png (120,125,3) 1` + + We use the image name without extension as the lmdb key. + Note that we use the same key for the corresponding lq and gt images. + + Args: + folders (list[str]): A list of folder path. The order of list should + be [input_folder, gt_folder]. + keys (list[str]): A list of keys identifying folders. The order should + be in consistent with folders, e.g., ['lq', 'gt']. + Note that this key is different from lmdb keys. + + Returns: + list[str]: Returned path list. + """ + assert len(folders) == 2, ('The len of folders should be 2 with [input_folder, gt_folder]. ' + f'But got {len(folders)}') + assert len(keys) == 2, f'The len of keys should be 2 with [input_key, gt_key]. But got {len(keys)}' + input_folder, gt_folder = folders + input_key, gt_key = keys + + if not (input_folder.endswith('.lmdb') and gt_folder.endswith('.lmdb')): + raise ValueError(f'{input_key} folder and {gt_key} folder should both in lmdb ' + f'formats. But received {input_key}: {input_folder}; ' + f'{gt_key}: {gt_folder}') + # ensure that the two meta_info files are the same + with open(osp.join(input_folder, 'meta_info.txt')) as fin: + input_lmdb_keys = [line.split('.')[0] for line in fin] + with open(osp.join(gt_folder, 'meta_info.txt')) as fin: + gt_lmdb_keys = [line.split('.')[0] for line in fin] + if set(input_lmdb_keys) != set(gt_lmdb_keys): + raise ValueError(f'Keys in {input_key}_folder and {gt_key}_folder are different.') + else: + paths = [] + for lmdb_key in sorted(input_lmdb_keys): + paths.append(dict([(f'{input_key}_path', lmdb_key), (f'{gt_key}_path', lmdb_key)])) + return paths + + +def paired_paths_from_meta_info_file(folders, keys, meta_info_file, filename_tmpl): + """Generate paired paths from an meta information file. + + Each line in the meta information file contains the image names and + image shape (usually for gt), separated by a white space. + + Example of an meta information file: + ``` + 0001_s001.png (480,480,3) + 0001_s002.png (480,480,3) + ``` + + Args: + folders (list[str]): A list of folder path. The order of list should + be [input_folder, gt_folder]. + keys (list[str]): A list of keys identifying folders. The order should + be in consistent with folders, e.g., ['lq', 'gt']. + meta_info_file (str): Path to the meta information file. + filename_tmpl (str): Template for each filename. Note that the + template excludes the file extension. Usually the filename_tmpl is + for files in the input folder. + + Returns: + list[str]: Returned path list. + """ + assert len(folders) == 2, ('The len of folders should be 2 with [input_folder, gt_folder]. ' + f'But got {len(folders)}') + assert len(keys) == 2, f'The len of keys should be 2 with [input_key, gt_key]. But got {len(keys)}' + input_folder, gt_folder = folders + input_key, gt_key = keys + + with open(meta_info_file, 'r') as fin: + gt_names = [line.split(' ')[0] for line in fin] + + paths = [] + for gt_name in gt_names: + basename, ext = osp.splitext(osp.basename(gt_name)) + input_name = f'{filename_tmpl.format(basename)}{ext}' + input_path = osp.join(input_folder, input_name) + gt_path = osp.join(gt_folder, gt_name) + paths.append(dict([(f'{input_key}_path', input_path), (f'{gt_key}_path', gt_path)])) + return paths + + +def paired_paths_from_folder(folders, keys, filename_tmpl): + """Generate paired paths from folders. + + Args: + folders (list[str]): A list of folder path. The order of list should + be [input_folder, gt_folder]. + keys (list[str]): A list of keys identifying folders. The order should + be in consistent with folders, e.g., ['lq', 'gt']. + filename_tmpl (str): Template for each filename. Note that the + template excludes the file extension. Usually the filename_tmpl is + for files in the input folder. + + Returns: + list[str]: Returned path list. + """ + assert len(folders) == 2, ('The len of folders should be 2 with [input_folder, gt_folder]. ' + f'But got {len(folders)}') + assert len(keys) == 2, f'The len of keys should be 2 with [input_key, gt_key]. But got {len(keys)}' + input_folder, gt_folder = folders + input_key, gt_key = keys + + input_paths = list(scandir(input_folder)) + gt_paths = list(scandir(gt_folder)) + assert len(input_paths) == len(gt_paths), (f'{input_key} and {gt_key} datasets have different number of images: ' + f'{len(input_paths)}, {len(gt_paths)}.') + paths = [] + for gt_path in gt_paths: + basename, ext = osp.splitext(osp.basename(gt_path)) + input_name = f'{filename_tmpl.format(basename)}{ext}' + input_path = osp.join(input_folder, input_name) + assert input_name in input_paths, f'{input_name} is not in {input_key}_paths.' + gt_path = osp.join(gt_folder, gt_path) + paths.append(dict([(f'{input_key}_path', input_path), (f'{gt_key}_path', gt_path)])) + return paths + + +def paths_from_folder(folder): + """Generate paths from folder. + + Args: + folder (str): Folder path. + + Returns: + list[str]: Returned path list. + """ + + paths = list(scandir(folder)) + paths = [osp.join(folder, path) for path in paths] + return paths + + +def paths_from_lmdb(folder): + """Generate paths from lmdb. + + Args: + folder (str): Folder path. + + Returns: + list[str]: Returned path list. + """ + if not folder.endswith('.lmdb'): + raise ValueError(f'Folder {folder}folder should in lmdb format.') + with open(osp.join(folder, 'meta_info.txt')) as fin: + paths = [line.split('.')[0] for line in fin] + return paths + + +def generate_gaussian_kernel(kernel_size=13, sigma=1.6): + """Generate Gaussian kernel used in `duf_downsample`. + + Args: + kernel_size (int): Kernel size. Default: 13. + sigma (float): Sigma of the Gaussian kernel. Default: 1.6. + + Returns: + np.array: The Gaussian kernel. + """ + from scipy.ndimage import filters as filters + kernel = np.zeros((kernel_size, kernel_size)) + # set element at the middle to one, a dirac delta + kernel[kernel_size // 2, kernel_size // 2] = 1 + # gaussian-smooth the dirac, resulting in a gaussian filter + return filters.gaussian_filter(kernel, sigma) + + +def duf_downsample(x, kernel_size=13, scale=4): + """Downsamping with Gaussian kernel used in the DUF official code. + + Args: + x (Tensor): Frames to be downsampled, with shape (b, t, c, h, w). + kernel_size (int): Kernel size. Default: 13. + scale (int): Downsampling factor. Supported scale: (2, 3, 4). + Default: 4. + + Returns: + Tensor: DUF downsampled frames. + """ + assert scale in (2, 3, 4), f'Only support scale (2, 3, 4), but got {scale}.' + + squeeze_flag = False + if x.ndim == 4: + squeeze_flag = True + x = x.unsqueeze(0) + b, t, c, h, w = x.size() + x = x.view(-1, 1, h, w) + pad_w, pad_h = kernel_size // 2 + scale * 2, kernel_size // 2 + scale * 2 + x = F.pad(x, (pad_w, pad_w, pad_h, pad_h), 'reflect') + + gaussian_filter = generate_gaussian_kernel(kernel_size, 0.4 * scale) + gaussian_filter = torch.from_numpy(gaussian_filter).type_as(x).unsqueeze(0).unsqueeze(0) + x = F.conv2d(x, gaussian_filter, stride=scale) + x = x[:, :, 2:-2, 2:-2] + x = x.view(b, t, c, x.size(2), x.size(3)) + if squeeze_flag: + x = x.squeeze(0) + return x diff --git a/basicsr/data/fmix.py b/basicsr/data/fmix.py new file mode 100644 index 0000000000000000000000000000000000000000..31c2073ba75e1c0180a63c73e4fd852af0d70aa1 --- /dev/null +++ b/basicsr/data/fmix.py @@ -0,0 +1,206 @@ +''' +Fmix paper from arxiv: https://arxiv.org/abs/2002.12047 +Fmix code from github : https://github.com/ecs-vlc/FMix +''' +import math +import random +import numpy as np +from scipy.stats import beta + + +def fftfreqnd(h, w=None, z=None): + """ Get bin values for discrete fourier transform of size (h, w, z) + :param h: Required, first dimension size + :param w: Optional, second dimension size + :param z: Optional, third dimension size + """ + fz = fx = 0 + fy = np.fft.fftfreq(h) + + if w is not None: + fy = np.expand_dims(fy, -1) + + if w % 2 == 1: + fx = np.fft.fftfreq(w)[: w // 2 + 2] + else: + fx = np.fft.fftfreq(w)[: w // 2 + 1] + + if z is not None: + fy = np.expand_dims(fy, -1) + if z % 2 == 1: + fz = np.fft.fftfreq(z)[:, None] + else: + fz = np.fft.fftfreq(z)[:, None] + + return np.sqrt(fx * fx + fy * fy + fz * fz) + + +def get_spectrum(freqs, decay_power, ch, h, w=0, z=0): + """ Samples a fourier image with given size and frequencies decayed by decay power + :param freqs: Bin values for the discrete fourier transform + :param decay_power: Decay power for frequency decay prop 1/f**d + :param ch: Number of channels for the resulting mask + :param h: Required, first dimension size + :param w: Optional, second dimension size + :param z: Optional, third dimension size + """ + scale = np.ones(1) / (np.maximum(freqs, np.array([1. / max(w, h, z)])) ** decay_power) + + param_size = [ch] + list(freqs.shape) + [2] + param = np.random.randn(*param_size) + + scale = np.expand_dims(scale, -1)[None, :] + + return scale * param + + +def make_low_freq_image(decay, shape, ch=1): + """ Sample a low frequency image from fourier space + :param decay_power: Decay power for frequency decay prop 1/f**d + :param shape: Shape of desired mask, list up to 3 dims + :param ch: Number of channels for desired mask + """ + freqs = fftfreqnd(*shape) + spectrum = get_spectrum(freqs, decay, ch, *shape)#.reshape((1, *shape[:-1], -1)) + spectrum = spectrum[:, 0] + 1j * spectrum[:, 1] + mask = np.real(np.fft.irfftn(spectrum, shape)) + + if len(shape) == 1: + mask = mask[:1, :shape[0]] + if len(shape) == 2: + mask = mask[:1, :shape[0], :shape[1]] + if len(shape) == 3: + mask = mask[:1, :shape[0], :shape[1], :shape[2]] + + mask = mask + mask = (mask - mask.min()) + mask = mask / mask.max() + return mask + + +def sample_lam(alpha, reformulate=False): + """ Sample a lambda from symmetric beta distribution with given alpha + :param alpha: Alpha value for beta distribution + :param reformulate: If True, uses the reformulation of [1]. + """ + if reformulate: + lam = beta.rvs(alpha+1, alpha) # rvs(arg1,arg2,loc=期望, scale=标准差, size=生成随机数的个数) 从分布中生成指定个数的随机数 + else: + lam = beta.rvs(alpha, alpha) # rvs(arg1,arg2,loc=期望, scale=标准差, size=生成随机数的个数) 从分布中生成指定个数的随机数 + + return lam + + +def binarise_mask(mask, lam, in_shape, max_soft=0.0): + """ Binarises a given low frequency image such that it has mean lambda. + :param mask: Low frequency image, usually the result of `make_low_freq_image` + :param lam: Mean value of final mask + :param in_shape: Shape of inputs + :param max_soft: Softening value between 0 and 0.5 which smooths hard edges in the mask. + :return: + """ + idx = mask.reshape(-1).argsort()[::-1] + mask = mask.reshape(-1) + num = math.ceil(lam * mask.size) if random.random() > 0.5 else math.floor(lam * mask.size) + + eff_soft = max_soft + if max_soft > lam or max_soft > (1-lam): + eff_soft = min(lam, 1-lam) + + soft = int(mask.size * eff_soft) + num_low = num - soft + num_high = num + soft + + mask[idx[:num_high]] = 1 + mask[idx[num_low:]] = 0 + mask[idx[num_low:num_high]] = np.linspace(1, 0, (num_high - num_low)) + + mask = mask.reshape((1, *in_shape)) + return mask + + +def sample_mask(alpha, decay_power, shape, max_soft=0.0, reformulate=False): + """ Samples a mean lambda from beta distribution parametrised by alpha, creates a low frequency image and binarises + it based on this lambda + :param alpha: Alpha value for beta distribution from which to sample mean of mask + :param decay_power: Decay power for frequency decay prop 1/f**d + :param shape: Shape of desired mask, list up to 3 dims + :param max_soft: Softening value between 0 and 0.5 which smooths hard edges in the mask. + :param reformulate: If True, uses the reformulation of [1]. + """ + if isinstance(shape, int): + shape = (shape,) + + # Choose lambda + lam = sample_lam(alpha, reformulate) + + # Make mask, get mean / std + mask = make_low_freq_image(decay_power, shape) + mask = binarise_mask(mask, lam, shape, max_soft) + + return lam, mask + + +def sample_and_apply(x, alpha, decay_power, shape, max_soft=0.0, reformulate=False): + """ + :param x: Image batch on which to apply fmix of shape [b, c, shape*] + :param alpha: Alpha value for beta distribution from which to sample mean of mask + :param decay_power: Decay power for frequency decay prop 1/f**d + :param shape: Shape of desired mask, list up to 3 dims + :param max_soft: Softening value between 0 and 0.5 which smooths hard edges in the mask. + :param reformulate: If True, uses the reformulation of [1]. + :return: mixed input, permutation indices, lambda value of mix, + """ + lam, mask = sample_mask(alpha, decay_power, shape, max_soft, reformulate) + index = np.random.permutation(x.shape[0]) + + x1, x2 = x * mask, x[index] * (1-mask) + return x1+x2, index, lam + + +class FMixBase: + """ FMix augmentation + Args: + decay_power (float): Decay power for frequency decay prop 1/f**d + alpha (float): Alpha value for beta distribution from which to sample mean of mask + size ([int] | [int, int] | [int, int, int]): Shape of desired mask, list up to 3 dims + max_soft (float): Softening value between 0 and 0.5 which smooths hard edges in the mask. + reformulate (bool): If True, uses the reformulation of [1]. + """ + + def __init__(self, decay_power=3, alpha=1, size=(32, 32), max_soft=0.0, reformulate=False): + super().__init__() + self.decay_power = decay_power + self.reformulate = reformulate + self.size = size + self.alpha = alpha + self.max_soft = max_soft + self.index = None + self.lam = None + + def __call__(self, x): + raise NotImplementedError + + def loss(self, *args, **kwargs): + raise NotImplementedError + + +if __name__ == '__main__': + # para = {'alpha':1.,'decay_power':3.,'shape':(10,10),'max_soft':0.0,'reformulate':False} + # lam, mask = sample_mask(**para) + # mask = mask.transpose(1, 2, 0) + # img1 = np.zeros((10, 10, 3)) + # img2 = np.ones((10, 10, 3)) + # img_gt = mask * img1 + (1. - mask) * img2 + # import ipdb; ipdb.set_trace() + + # test + import cv2 + i1 = cv2.imread('output/ILSVRC2012_val_00000001.JPEG') + i2 = cv2.imread('output/ILSVRC2012_val_00000002.JPEG') + para = {'alpha':1.,'decay_power':3.,'shape':(256, 256),'max_soft':0.0,'reformulate':False} + lam, mask = sample_mask(**para) + mask = mask.transpose(1, 2, 0) + i = mask * i1 + (1. - mask) * i2 + #i = i.astype(np.uint8) + cv2.imwrite('fmix.jpg', i) \ No newline at end of file diff --git a/basicsr/data/lab_dataset.py b/basicsr/data/lab_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..000920f6b944cbbfee9f2592b7882e1a9c2c86ba --- /dev/null +++ b/basicsr/data/lab_dataset.py @@ -0,0 +1,159 @@ +import cv2 +import random +import time +import numpy as np +import torch +from torch.utils import data as data + +from basicsr.data.transforms import rgb2lab +from basicsr.utils import FileClient, get_root_logger, imfrombytes, img2tensor +from basicsr.utils.registry import DATASET_REGISTRY +from basicsr.data.fmix import sample_mask + + +@DATASET_REGISTRY.register() +class LabDataset(data.Dataset): + """ + Dataset used for Lab colorizaion + """ + + def __init__(self, opt): + super(LabDataset, self).__init__() + self.opt = opt + # file client (io backend) + self.file_client = None + self.io_backend_opt = opt['io_backend'] + self.gt_folder = opt['dataroot_gt'] + + meta_info_file = self.opt['meta_info_file'] + assert meta_info_file is not None + if not isinstance(meta_info_file, list): + meta_info_file = [meta_info_file] + self.paths = [] + for meta_info in meta_info_file: + with open(meta_info, 'r') as fin: + self.paths.extend([line.strip() for line in fin]) + + self.min_ab, self.max_ab = -128, 128 + self.interval_ab = 4 + self.ab_palette = [i for i in range(self.min_ab, self.max_ab + self.interval_ab, self.interval_ab)] + # print(self.ab_palette) + + self.do_fmix = opt['do_fmix'] + self.fmix_params = {'alpha':1.,'decay_power':3.,'shape':(256,256),'max_soft':0.0,'reformulate':False} + self.fmix_p = opt['fmix_p'] + self.do_cutmix = opt['do_cutmix'] + self.cutmix_params = {'alpha':1.} + self.cutmix_p = opt['cutmix_p'] + + + def __getitem__(self, index): + if self.file_client is None: + self.file_client = FileClient(self.io_backend_opt.pop('type'), **self.io_backend_opt) + + # -------------------------------- Load gt images -------------------------------- # + # Shape: (h, w, c); channel order: BGR; image range: [0, 1], float32. + gt_path = self.paths[index] + gt_size = self.opt['gt_size'] + # avoid errors caused by high latency in reading files + retry = 3 + while retry > 0: + try: + img_bytes = self.file_client.get(gt_path, 'gt') + except Exception as e: + logger = get_root_logger() + logger.warn(f'File client error: {e}, remaining retry times: {retry - 1}') + # change another file to read + index = random.randint(0, self.__len__()) + gt_path = self.paths[index] + time.sleep(1) # sleep 1s for occasional server congestion + else: + break + finally: + retry -= 1 + img_gt = imfrombytes(img_bytes, float32=True) + img_gt = cv2.resize(img_gt, (gt_size, gt_size)) # TODO: 直接resize是否是最佳方案？ + + # -------------------------------- (Optional) CutMix & FMix -------------------------------- # + if self.do_fmix and np.random.uniform(0., 1., size=1)[0] > self.fmix_p: + with torch.no_grad(): + lam, mask = sample_mask(**self.fmix_params) + + fmix_index = random.randint(0, self.__len__()) + fmix_img_path = self.paths[fmix_index] + fmix_img_bytes = self.file_client.get(fmix_img_path, 'gt') + fmix_img = imfrombytes(fmix_img_bytes, float32=True) + fmix_img = cv2.resize(fmix_img, (gt_size, gt_size)) + + mask = mask.transpose(1, 2, 0) # (1, 256, 256) -> # (256, 256, 1) + img_gt = mask * img_gt + (1. - mask) * fmix_img + img_gt = img_gt.astype(np.float32) + + if self.do_cutmix and np.random.uniform(0., 1., size=1)[0] > self.cutmix_p: + with torch.no_grad(): + cmix_index = random.randint(0, self.__len__()) + cmix_img_path = self.paths[cmix_index] + cmix_img_bytes = self.file_client.get(cmix_img_path, 'gt') + cmix_img = imfrombytes(cmix_img_bytes, float32=True) + cmix_img = cv2.resize(cmix_img, (gt_size, gt_size)) + + lam = np.clip(np.random.beta(self.cutmix_params['alpha'], self.cutmix_params['alpha']), 0.3, 0.4) + bbx1, bby1, bbx2, bby2 = rand_bbox(cmix_img.shape[:2], lam) + + img_gt[:, bbx1:bbx2, bby1:bby2] = cmix_img[:, bbx1:bbx2, bby1:bby2] + + + # ----------------------------- Get gray lq, to tentor ----------------------------- # + # convert to gray + img_gt = cv2.cvtColor(img_gt, cv2.COLOR_BGR2RGB) + img_l, img_ab = rgb2lab(img_gt) + + target_a, target_b = self.ab2int(img_ab) + + # numpy to tensor + img_l, img_ab = img2tensor([img_l, img_ab], bgr2rgb=False, float32=True) + target_a, target_b = torch.LongTensor(target_a), torch.LongTensor(target_b) + return_d = { + 'lq': img_l, + 'gt': img_ab, + 'target_a': target_a, + 'target_b': target_b, + 'lq_path': gt_path, + 'gt_path': gt_path + } + return return_d + + def ab2int(self, img_ab): + img_a, img_b = img_ab[:, :, 0], img_ab[:, :, 1] + int_a = (img_a - self.min_ab) / self.interval_ab + int_b = (img_b - self.min_ab) / self.interval_ab + + return np.round(int_a), np.round(int_b) + + def __len__(self): + return len(self.paths) + + +def rand_bbox(size, lam): + '''cutmix 的 bbox 截取函数 + Args: + size : tuple 图片尺寸 e.g (256,256) + lam : float 截取比例 + Returns: + bbox 的左上角和右下角坐标 + int,int,int,int + ''' + W = size[0] # 截取图片的宽度 + H = size[1] # 截取图片的高度 + cut_rat = np.sqrt(1. - lam) # 需要截取的 bbox 比例 + cut_w = np.int(W * cut_rat) # 需要截取的 bbox 宽度 + cut_h = np.int(H * cut_rat) # 需要截取的 bbox 高度 + + cx = np.random.randint(W) # 均匀分布采样，随机选择截取的 bbox 的中心点 x 坐标 + cy = np.random.randint(H) # 均匀分布采样，随机选择截取的 bbox 的中心点 y 坐标 + + bbx1 = np.clip(cx - cut_w // 2, 0, W) # 左上角 x 坐标 + bby1 = np.clip(cy - cut_h // 2, 0, H) # 左上角 y 坐标 + bbx2 = np.clip(cx + cut_w // 2, 0, W) # 右下角 x 坐标 + bby2 = np.clip(cy + cut_h // 2, 0, H) # 右下角 y 坐标 + return bbx1, bby1, bbx2, bby2 \ No newline at end of file diff --git a/basicsr/data/prefetch_dataloader.py b/basicsr/data/prefetch_dataloader.py new file mode 100644 index 0000000000000000000000000000000000000000..5088425050d4cc98114a9b93eb50ea60273f35a0 --- /dev/null +++ b/basicsr/data/prefetch_dataloader.py @@ -0,0 +1,125 @@ +import queue as Queue +import threading +import torch +from torch.utils.data import DataLoader + + +class PrefetchGenerator(threading.Thread): + """A general prefetch generator. + + Ref: + https://stackoverflow.com/questions/7323664/python-generator-pre-fetch + + Args: + generator: Python generator. + num_prefetch_queue (int): Number of prefetch queue. + """ + + def __init__(self, generator, num_prefetch_queue): + threading.Thread.__init__(self) + self.queue = Queue.Queue(num_prefetch_queue) + self.generator = generator + self.daemon = True + self.start() + + def run(self): + for item in self.generator: + self.queue.put(item) + self.queue.put(None) + + def __next__(self): + next_item = self.queue.get() + if next_item is None: + raise StopIteration + return next_item + + def __iter__(self): + return self + + +class PrefetchDataLoader(DataLoader): + """Prefetch version of dataloader. + + Ref: + https://github.com/IgorSusmelj/pytorch-styleguide/issues/5# + + TODO: + Need to test on single gpu and ddp (multi-gpu). There is a known issue in + ddp. + + Args: + num_prefetch_queue (int): Number of prefetch queue. + kwargs (dict): Other arguments for dataloader. + """ + + def __init__(self, num_prefetch_queue, **kwargs): + self.num_prefetch_queue = num_prefetch_queue + super(PrefetchDataLoader, self).__init__(**kwargs) + + def __iter__(self): + return PrefetchGenerator(super().__iter__(), self.num_prefetch_queue) + + +class CPUPrefetcher(): + """CPU prefetcher. + + Args: + loader: Dataloader. + """ + + def __init__(self, loader): + self.ori_loader = loader + self.loader = iter(loader) + + def next(self): + try: + return next(self.loader) + except StopIteration: + return None + + def reset(self): + self.loader = iter(self.ori_loader) + + +class CUDAPrefetcher(): + """CUDA prefetcher. + + Ref: + https://github.com/NVIDIA/apex/issues/304# + + It may consums more GPU memory. + + Args: + loader: Dataloader. + opt (dict): Options. + """ + + def __init__(self, loader, opt): + self.ori_loader = loader + self.loader = iter(loader) + self.opt = opt + self.stream = torch.cuda.Stream() + self.device = torch.device('cuda' if opt['num_gpu'] != 0 else 'cpu') + self.preload() + + def preload(self): + try: + self.batch = next(self.loader) # self.batch is a dict + except StopIteration: + self.batch = None + return None + # put tensors to gpu + with torch.cuda.stream(self.stream): + for k, v in self.batch.items(): + if torch.is_tensor(v): + self.batch[k] = self.batch[k].to(device=self.device, non_blocking=True) + + def next(self): + torch.cuda.current_stream().wait_stream(self.stream) + batch = self.batch + self.preload() + return batch + + def reset(self): + self.loader = iter(self.ori_loader) + self.preload() diff --git a/basicsr/data/transforms.py b/basicsr/data/transforms.py new file mode 100644 index 0000000000000000000000000000000000000000..0f623c4eb42df8e694ccec4f41029a16ac0c9faf --- /dev/null +++ b/basicsr/data/transforms.py @@ -0,0 +1,192 @@ +import cv2 +import numpy as np +import torch +import random +from scipy import special +from skimage import color + + +def mod_crop(img, scale): + """Mod crop images, used during testing. + + Args: + img (ndarray): Input image. + scale (int): Scale factor. + + Returns: + ndarray: Result image. + """ + img = img.copy() + if img.ndim in (2, 3): + h, w = img.shape[0], img.shape[1] + h_remainder, w_remainder = h % scale, w % scale + img = img[:h - h_remainder, :w - w_remainder, ...] + else: + raise ValueError(f'Wrong img ndim: {img.ndim}.') + return img + + +def paired_random_crop(img_gts, img_lqs, gt_patch_size, scale, gt_path=None): + """Paired random crop. Support Numpy array and Tensor inputs. + + It crops lists of lq and gt images with corresponding locations. + + Args: + img_gts (list[ndarray] | ndarray | list[Tensor] | Tensor): GT images. Note that all images + should have the same shape. If the input is an ndarray, it will + be transformed to a list containing itself. + img_lqs (list[ndarray] | ndarray): LQ images. Note that all images + should have the same shape. If the input is an ndarray, it will + be transformed to a list containing itself. + gt_patch_size (int): GT patch size. + scale (int): Scale factor. + gt_path (str): Path to ground-truth. Default: None. + + Returns: + list[ndarray] | ndarray: GT images and LQ images. If returned results + only have one element, just return ndarray. + """ + + if not isinstance(img_gts, list): + img_gts = [img_gts] + if not isinstance(img_lqs, list): + img_lqs = [img_lqs] + + # determine input type: Numpy array or Tensor + input_type = 'Tensor' if torch.is_tensor(img_gts[0]) else 'Numpy' + + if input_type == 'Tensor': + h_lq, w_lq = img_lqs[0].size()[-2:] + h_gt, w_gt = img_gts[0].size()[-2:] + else: + h_lq, w_lq = img_lqs[0].shape[0:2] + h_gt, w_gt = img_gts[0].shape[0:2] + lq_patch_size = gt_patch_size // scale + + if h_gt != h_lq * scale or w_gt != w_lq * scale: + raise ValueError(f'Scale mismatches. GT ({h_gt}, {w_gt}) is not {scale}x ', + f'multiplication of LQ ({h_lq}, {w_lq}).') + if h_lq < lq_patch_size or w_lq < lq_patch_size: + raise ValueError(f'LQ ({h_lq}, {w_lq}) is smaller than patch size ' + f'({lq_patch_size}, {lq_patch_size}). ' + f'Please remove {gt_path}.') + + # randomly choose top and left coordinates for lq patch + top = random.randint(0, h_lq - lq_patch_size) + left = random.randint(0, w_lq - lq_patch_size) + + # crop lq patch + if input_type == 'Tensor': + img_lqs = [v[:, :, top:top + lq_patch_size, left:left + lq_patch_size] for v in img_lqs] + else: + img_lqs = [v[top:top + lq_patch_size, left:left + lq_patch_size, ...] for v in img_lqs] + + # crop corresponding gt patch + top_gt, left_gt = int(top * scale), int(left * scale) + if input_type == 'Tensor': + img_gts = [v[:, :, top_gt:top_gt + gt_patch_size, left_gt:left_gt + gt_patch_size] for v in img_gts] + else: + img_gts = [v[top_gt:top_gt + gt_patch_size, left_gt:left_gt + gt_patch_size, ...] for v in img_gts] + if len(img_gts) == 1: + img_gts = img_gts[0] + if len(img_lqs) == 1: + img_lqs = img_lqs[0] + return img_gts, img_lqs + + +def augment(imgs, hflip=True, rotation=True, flows=None, return_status=False): + """Augment: horizontal flips OR rotate (0, 90, 180, 270 degrees). + + We use vertical flip and transpose for rotation implementation. + All the images in the list use the same augmentation. + + Args: + imgs (list[ndarray] | ndarray): Images to be augmented. If the input + is an ndarray, it will be transformed to a list. + hflip (bool): Horizontal flip. Default: True. + rotation (bool): Ratotation. Default: True. + flows (list[ndarray]: Flows to be augmented. If the input is an + ndarray, it will be transformed to a list. + Dimension is (h, w, 2). Default: None. + return_status (bool): Return the status of flip and rotation. + Default: False. + + Returns: + list[ndarray] | ndarray: Augmented images and flows. If returned + results only have one element, just return ndarray. + + """ + hflip = hflip and random.random() < 0.5 + vflip = rotation and random.random() < 0.5 + rot90 = rotation and random.random() < 0.5 + + def _augment(img): + if hflip: # horizontal + cv2.flip(img, 1, img) + if vflip: # vertical + cv2.flip(img, 0, img) + if rot90: + img = img.transpose(1, 0, 2) + return img + + def _augment_flow(flow): + if hflip: # horizontal + cv2.flip(flow, 1, flow) + flow[:, :, 0] *= -1 + if vflip: # vertical + cv2.flip(flow, 0, flow) + flow[:, :, 1] *= -1 + if rot90: + flow = flow.transpose(1, 0, 2) + flow = flow[:, :, [1, 0]] + return flow + + if not isinstance(imgs, list): + imgs = [imgs] + imgs = [_augment(img) for img in imgs] + if len(imgs) == 1: + imgs = imgs[0] + + if flows is not None: + if not isinstance(flows, list): + flows = [flows] + flows = [_augment_flow(flow) for flow in flows] + if len(flows) == 1: + flows = flows[0] + return imgs, flows + else: + if return_status: + return imgs, (hflip, vflip, rot90) + else: + return imgs + + +def img_rotate(img, angle, center=None, scale=1.0, borderMode=cv2.BORDER_CONSTANT, borderValue=0.): + """Rotate image. + + Args: + img (ndarray): Image to be rotated. + angle (float): Rotation angle in degrees. Positive values mean + counter-clockwise rotation. + center (tuple[int]): Rotation center. If the center is None, + initialize it as the center of the image. Default: None. + scale (float): Isotropic scale factor. Default: 1.0. + """ + (h, w) = img.shape[:2] + + if center is None: + center = (w // 2, h // 2) + + matrix = cv2.getRotationMatrix2D(center, angle, scale) + rotated_img = cv2.warpAffine(img, matrix, (w, h), borderMode=borderMode, borderValue=borderValue) + return rotated_img + + +def rgb2lab(img_rgb): + img_lab = color.rgb2lab(img_rgb) + img_l = img_lab[:, :, :1] + img_ab = img_lab[:, :, 1:] + return img_l, img_ab + + + diff --git a/basicsr/losses/__init__.py b/basicsr/losses/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b1570dd2d683ba5983bfc715d37fc611af7b6ba5 --- /dev/null +++ b/basicsr/losses/__init__.py @@ -0,0 +1,26 @@ +from copy import deepcopy + +from basicsr.utils import get_root_logger +from basicsr.utils.registry import LOSS_REGISTRY +from .losses import (CharbonnierLoss, GANLoss, L1Loss, MSELoss, PerceptualLoss, WeightedTVLoss, g_path_regularize, + gradient_penalty_loss, r1_penalty) + +__all__ = [ + 'L1Loss', 'MSELoss', 'CharbonnierLoss', 'WeightedTVLoss', 'PerceptualLoss', 'GANLoss', 'gradient_penalty_loss', + 'r1_penalty', 'g_path_regularize' +] + + +def build_loss(opt): + """Build loss from options. + + Args: + opt (dict): Configuration. It must contain: + type (str): Model type. + """ + opt = deepcopy(opt) + loss_type = opt.pop('type') + loss = LOSS_REGISTRY.get(loss_type)(**opt) + logger = get_root_logger() + logger.info(f'Loss [{loss.__class__.__name__}] is created.') + return loss diff --git a/basicsr/losses/loss_util.py b/basicsr/losses/loss_util.py new file mode 100644 index 0000000000000000000000000000000000000000..744eeb46d1f3b5a7b4553ca23237ddd9c899a698 --- /dev/null +++ b/basicsr/losses/loss_util.py @@ -0,0 +1,95 @@ +import functools +from torch.nn import functional as F + + +def reduce_loss(loss, reduction): + """Reduce loss as specified. + + Args: + loss (Tensor): Elementwise loss tensor. + reduction (str): Options are 'none', 'mean' and 'sum'. + + Returns: + Tensor: Reduced loss tensor. + """ + reduction_enum = F._Reduction.get_enum(reduction) + # none: 0, elementwise_mean:1, sum: 2 + if reduction_enum == 0: + return loss + elif reduction_enum == 1: + return loss.mean() + else: + return loss.sum() + + +def weight_reduce_loss(loss, weight=None, reduction='mean'): + """Apply element-wise weight and reduce loss. + + Args: + loss (Tensor): Element-wise loss. + weight (Tensor): Element-wise weights. Default: None. + reduction (str): Same as built-in losses of PyTorch. Options are + 'none', 'mean' and 'sum'. Default: 'mean'. + + Returns: + Tensor: Loss values. + """ + # if weight is specified, apply element-wise weight + if weight is not None: + assert weight.dim() == loss.dim() + assert weight.size(1) == 1 or weight.size(1) == loss.size(1) + loss = loss * weight + + # if weight is not specified or reduction is sum, just reduce the loss + if weight is None or reduction == 'sum': + loss = reduce_loss(loss, reduction) + # if reduction is mean, then compute mean over weight region + elif reduction == 'mean': + if weight.size(1) > 1: + weight = weight.sum() + else: + weight = weight.sum() * loss.size(1) + loss = loss.sum() / weight + + return loss + + +def weighted_loss(loss_func): + """Create a weighted version of a given loss function. + + To use this decorator, the loss function must have the signature like + `loss_func(pred, target, **kwargs)`. The function only needs to compute + element-wise loss without any reduction. This decorator will add weight + and reduction arguments to the function. The decorated function will have + the signature like `loss_func(pred, target, weight=None, reduction='mean', + **kwargs)`. + + :Example: + + >>> import torch + >>> @weighted_loss + >>> def l1_loss(pred, target): + >>> return (pred - target).abs() + + >>> pred = torch.Tensor([0, 2, 3]) + >>> target = torch.Tensor([1, 1, 1]) + >>> weight = torch.Tensor([1, 0, 1]) + + >>> l1_loss(pred, target) + tensor(1.3333) + >>> l1_loss(pred, target, weight) + tensor(1.5000) + >>> l1_loss(pred, target, reduction='none') + tensor([1., 1., 2.]) + >>> l1_loss(pred, target, weight, reduction='sum') + tensor(3.) + """ + + @functools.wraps(loss_func) + def wrapper(pred, target, weight=None, reduction='mean', **kwargs): + # get element-wise loss + loss = loss_func(pred, target, **kwargs) + loss = weight_reduce_loss(loss, weight, reduction) + return loss + + return wrapper diff --git a/basicsr/losses/losses.py b/basicsr/losses/losses.py new file mode 100644 index 0000000000000000000000000000000000000000..46b0a415560befbe0a98b9687ab99161c624e042 --- /dev/null +++ b/basicsr/losses/losses.py @@ -0,0 +1,551 @@ +import math +import torch +from torch import autograd as autograd +from torch import nn as nn +from torch.nn import functional as F + +from basicsr.archs.vgg_arch import VGGFeatureExtractor +from basicsr.utils.registry import LOSS_REGISTRY +from .loss_util import weighted_loss + +_reduction_modes = ['none', 'mean', 'sum'] + + +@weighted_loss +def l1_loss(pred, target): + return F.l1_loss(pred, target, reduction='none') + + +@weighted_loss +def mse_loss(pred, target): + return F.mse_loss(pred, target, reduction='none') + + +@weighted_loss +def charbonnier_loss(pred, target, eps=1e-12): + return torch.sqrt((pred - target)**2 + eps) + + +@LOSS_REGISTRY.register() +class L1Loss(nn.Module): + """L1 (mean absolute error, MAE) loss. + + Args: + loss_weight (float): Loss weight for L1 loss. Default: 1.0. + reduction (str): Specifies the reduction to apply to the output. + Supported choices are 'none' | 'mean' | 'sum'. Default: 'mean'. + """ + + def __init__(self, loss_weight=1.0, reduction='mean'): + super(L1Loss, self).__init__() + if reduction not in ['none', 'mean', 'sum']: + raise ValueError(f'Unsupported reduction mode: {reduction}. Supported ones are: {_reduction_modes}') + + self.loss_weight = loss_weight + self.reduction = reduction + + def forward(self, pred, target, weight=None, **kwargs): + """ + Args: + pred (Tensor): of shape (N, C, H, W). Predicted tensor. + target (Tensor): of shape (N, C, H, W). Ground truth tensor. + weight (Tensor, optional): of shape (N, C, H, W). Element-wise + weights. Default: None. + """ + return self.loss_weight * l1_loss(pred, target, weight, reduction=self.reduction) + + +@LOSS_REGISTRY.register() +class MSELoss(nn.Module): + """MSE (L2) loss. + + Args: + loss_weight (float): Loss weight for MSE loss. Default: 1.0. + reduction (str): Specifies the reduction to apply to the output. + Supported choices are 'none' | 'mean' | 'sum'. Default: 'mean'. + """ + + def __init__(self, loss_weight=1.0, reduction='mean'): + super(MSELoss, self).__init__() + if reduction not in ['none', 'mean', 'sum']: + raise ValueError(f'Unsupported reduction mode: {reduction}. Supported ones are: {_reduction_modes}') + + self.loss_weight = loss_weight + self.reduction = reduction + + def forward(self, pred, target, weight=None, **kwargs): + """ + Args: + pred (Tensor): of shape (N, C, H, W). Predicted tensor. + target (Tensor): of shape (N, C, H, W). Ground truth tensor. + weight (Tensor, optional): of shape (N, C, H, W). Element-wise + weights. Default: None. + """ + return self.loss_weight * mse_loss(pred, target, weight, reduction=self.reduction) + + +@LOSS_REGISTRY.register() +class CharbonnierLoss(nn.Module): + """Charbonnier loss (one variant of Robust L1Loss, a differentiable + variant of L1Loss). + + Described in "Deep Laplacian Pyramid Networks for Fast and Accurate + Super-Resolution". + + Args: + loss_weight (float): Loss weight for L1 loss. Default: 1.0. + reduction (str): Specifies the reduction to apply to the output. + Supported choices are 'none' | 'mean' | 'sum'. Default: 'mean'. + eps (float): A value used to control the curvature near zero. + Default: 1e-12. + """ + + def __init__(self, loss_weight=1.0, reduction='mean', eps=1e-12): + super(CharbonnierLoss, self).__init__() + if reduction not in ['none', 'mean', 'sum']: + raise ValueError(f'Unsupported reduction mode: {reduction}. Supported ones are: {_reduction_modes}') + + self.loss_weight = loss_weight + self.reduction = reduction + self.eps = eps + + def forward(self, pred, target, weight=None, **kwargs): + """ + Args: + pred (Tensor): of shape (N, C, H, W). Predicted tensor. + target (Tensor): of shape (N, C, H, W). Ground truth tensor. + weight (Tensor, optional): of shape (N, C, H, W). Element-wise + weights. Default: None. + """ + return self.loss_weight * charbonnier_loss(pred, target, weight, eps=self.eps, reduction=self.reduction) + + +@LOSS_REGISTRY.register() +class WeightedTVLoss(L1Loss): + """Weighted TV loss. + + Args: + loss_weight (float): Loss weight. Default: 1.0. + """ + + def __init__(self, loss_weight=1.0): + super(WeightedTVLoss, self).__init__(loss_weight=loss_weight) + + def forward(self, pred, weight=None): + if weight is None: + y_weight = None + x_weight = None + else: + y_weight = weight[:, :, :-1, :] + x_weight = weight[:, :, :, :-1] + + y_diff = super(WeightedTVLoss, self).forward(pred[:, :, :-1, :], pred[:, :, 1:, :], weight=y_weight) + x_diff = super(WeightedTVLoss, self).forward(pred[:, :, :, :-1], pred[:, :, :, 1:], weight=x_weight) + + loss = x_diff + y_diff + + return loss + + +@LOSS_REGISTRY.register() +class PerceptualLoss(nn.Module): + """Perceptual loss with commonly used style loss. + + Args: + layer_weights (dict): The weight for each layer of vgg feature. + Here is an example: {'conv5_4': 1.}, which means the conv5_4 + feature layer (before relu5_4) will be extracted with weight + 1.0 in calculating losses. + vgg_type (str): The type of vgg network used as feature extractor. + Default: 'vgg19'. + use_input_norm (bool): If True, normalize the input image in vgg. + Default: True. + range_norm (bool): If True, norm images with range [-1, 1] to [0, 1]. + Default: False. + perceptual_weight (float): If `perceptual_weight > 0`, the perceptual + loss will be calculated and the loss will multiplied by the + weight. Default: 1.0. + style_weight (float): If `style_weight > 0`, the style loss will be + calculated and the loss will multiplied by the weight. + Default: 0. + criterion (str): Criterion used for perceptual loss. Default: 'l1'. + """ + + def __init__(self, + layer_weights, + vgg_type='vgg19', + use_input_norm=True, + range_norm=False, + perceptual_weight=1.0, + style_weight=0., + criterion='l1'): + super(PerceptualLoss, self).__init__() + self.perceptual_weight = perceptual_weight + self.style_weight = style_weight + self.layer_weights = layer_weights + self.vgg = VGGFeatureExtractor( + layer_name_list=list(layer_weights.keys()), + vgg_type=vgg_type, + use_input_norm=use_input_norm, + range_norm=range_norm) + + self.criterion_type = criterion + if self.criterion_type == 'l1': + self.criterion = torch.nn.L1Loss() + elif self.criterion_type == 'l2': + self.criterion = torch.nn.L2loss() + elif self.criterion_type == 'fro': + self.criterion = None + else: + raise NotImplementedError(f'{criterion} criterion has not been supported.') + + def forward(self, x, gt): + """Forward function. + + Args: + x (Tensor): Input tensor with shape (n, c, h, w). + gt (Tensor): Ground-truth tensor with shape (n, c, h, w). + + Returns: + Tensor: Forward results. + """ + # extract vgg features + x_features = self.vgg(x) + gt_features = self.vgg(gt.detach()) + + # calculate perceptual loss + if self.perceptual_weight > 0: + percep_loss = 0 + for k in x_features.keys(): + if self.criterion_type == 'fro': + percep_loss += torch.norm(x_features[k] - gt_features[k], p='fro') * self.layer_weights[k] + else: + percep_loss += self.criterion(x_features[k], gt_features[k]) * self.layer_weights[k] + percep_loss *= self.perceptual_weight + else: + percep_loss = None + + # calculate style loss + if self.style_weight > 0: + style_loss = 0 + for k in x_features.keys(): + if self.criterion_type == 'fro': + style_loss += torch.norm( + self._gram_mat(x_features[k]) - self._gram_mat(gt_features[k]), p='fro') * self.layer_weights[k] + else: + style_loss += self.criterion(self._gram_mat(x_features[k]), self._gram_mat( + gt_features[k])) * self.layer_weights[k] + style_loss *= self.style_weight + else: + style_loss = None + + return percep_loss, style_loss + + def _gram_mat(self, x): + """Calculate Gram matrix. + + Args: + x (torch.Tensor): Tensor with shape of (n, c, h, w). + + Returns: + torch.Tensor: Gram matrix. + """ + n, c, h, w = x.size() + features = x.view(n, c, w * h) + features_t = features.transpose(1, 2) + gram = features.bmm(features_t) / (c * h * w) + return gram + + +@LOSS_REGISTRY.register() +class GANLoss(nn.Module): + """Define GAN loss. + + Args: + gan_type (str): Support 'vanilla', 'lsgan', 'wgan', 'hinge'. + real_label_val (float): The value for real label. Default: 1.0. + fake_label_val (float): The value for fake label. Default: 0.0. + loss_weight (float): Loss weight. Default: 1.0. + Note that loss_weight is only for generators; and it is always 1.0 + for discriminators. + """ + + def __init__(self, gan_type, real_label_val=1.0, fake_label_val=0.0, loss_weight=1.0): + super(GANLoss, self).__init__() + self.gan_type = gan_type + self.loss_weight = loss_weight + self.real_label_val = real_label_val + self.fake_label_val = fake_label_val + + if self.gan_type == 'vanilla': + self.loss = nn.BCEWithLogitsLoss() + elif self.gan_type == 'lsgan': + self.loss = nn.MSELoss() + elif self.gan_type == 'wgan': + self.loss = self._wgan_loss + elif self.gan_type == 'wgan_softplus': + self.loss = self._wgan_softplus_loss + elif self.gan_type == 'hinge': + self.loss = nn.ReLU() + else: + raise NotImplementedError(f'GAN type {self.gan_type} is not implemented.') + + def _wgan_loss(self, input, target): + """wgan loss. + + Args: + input (Tensor): Input tensor. + target (bool): Target label. + + Returns: + Tensor: wgan loss. + """ + return -input.mean() if target else input.mean() + + def _wgan_softplus_loss(self, input, target): + """wgan loss with soft plus. softplus is a smooth approximation to the + ReLU function. + + In StyleGAN2, it is called: + Logistic loss for discriminator; + Non-saturating loss for generator. + + Args: + input (Tensor): Input tensor. + target (bool): Target label. + + Returns: + Tensor: wgan loss. + """ + return F.softplus(-input).mean() if target else F.softplus(input).mean() + + def get_target_label(self, input, target_is_real): + """Get target label. + + Args: + input (Tensor): Input tensor. + target_is_real (bool): Whether the target is real or fake. + + Returns: + (bool | Tensor): Target tensor. Return bool for wgan, otherwise, + return Tensor. + """ + + if self.gan_type in ['wgan', 'wgan_softplus']: + return target_is_real + target_val = (self.real_label_val if target_is_real else self.fake_label_val) + return input.new_ones(input.size()) * target_val + + def forward(self, input, target_is_real, is_disc=False): + """ + Args: + input (Tensor): The input for the loss module, i.e., the network + prediction. + target_is_real (bool): Whether the targe is real or fake. + is_disc (bool): Whether the loss for discriminators or not. + Default: False. + + Returns: + Tensor: GAN loss value. + """ + target_label = self.get_target_label(input, target_is_real) + if self.gan_type == 'hinge': + if is_disc: # for discriminators in hinge-gan + input = -input if target_is_real else input + loss = self.loss(1 + input).mean() + else: # for generators in hinge-gan + loss = -input.mean() + else: # other gan types + loss = self.loss(input, target_label) + + # loss_weight is always 1.0 for discriminators + return loss if is_disc else loss * self.loss_weight + + +@LOSS_REGISTRY.register() +class MultiScaleGANLoss(GANLoss): + """ + MultiScaleGANLoss accepts a list of predictions + """ + + def __init__(self, gan_type, real_label_val=1.0, fake_label_val=0.0, loss_weight=1.0): + super(MultiScaleGANLoss, self).__init__(gan_type, real_label_val, fake_label_val, loss_weight) + + def forward(self, input, target_is_real, is_disc=False): + """ + The input is a list of tensors, or a list of (a list of tensors) + """ + if isinstance(input, list): + loss = 0 + for pred_i in input: + if isinstance(pred_i, list): + # Only compute GAN loss for the last layer + # in case of multiscale feature matching + pred_i = pred_i[-1] + # Safe operation: 0-dim tensor calling self.mean() does nothing + loss_tensor = super().forward(pred_i, target_is_real, is_disc).mean() + loss += loss_tensor + return loss / len(input) + else: + return super().forward(input, target_is_real, is_disc) + + +def r1_penalty(real_pred, real_img): + """R1 regularization for discriminator. The core idea is to + penalize the gradient on real data alone: when the + generator distribution produces the true data distribution + and the discriminator is equal to 0 on the data manifold, the + gradient penalty ensures that the discriminator cannot create + a non-zero gradient orthogonal to the data manifold without + suffering a loss in the GAN game. + + Ref: + Eq. 9 in Which training methods for GANs do actually converge. + """ + grad_real = autograd.grad(outputs=real_pred.sum(), inputs=real_img, create_graph=True)[0] + grad_penalty = grad_real.pow(2).view(grad_real.shape[0], -1).sum(1).mean() + return grad_penalty + + +def g_path_regularize(fake_img, latents, mean_path_length, decay=0.01): + noise = torch.randn_like(fake_img) / math.sqrt(fake_img.shape[2] * fake_img.shape[3]) + grad = autograd.grad(outputs=(fake_img * noise).sum(), inputs=latents, create_graph=True)[0] + path_lengths = torch.sqrt(grad.pow(2).sum(2).mean(1)) + + path_mean = mean_path_length + decay * (path_lengths.mean() - mean_path_length) + + path_penalty = (path_lengths - path_mean).pow(2).mean() + + return path_penalty, path_lengths.detach().mean(), path_mean.detach() + + +def gradient_penalty_loss(discriminator, real_data, fake_data, weight=None): + """Calculate gradient penalty for wgan-gp. + + Args: + discriminator (nn.Module): Network for the discriminator. + real_data (Tensor): Real input data. + fake_data (Tensor): Fake input data. + weight (Tensor): Weight tensor. Default: None. + + Returns: + Tensor: A tensor for gradient penalty. + """ + + batch_size = real_data.size(0) + alpha = real_data.new_tensor(torch.rand(batch_size, 1, 1, 1)) + + # interpolate between real_data and fake_data + interpolates = alpha * real_data + (1. - alpha) * fake_data + interpolates = autograd.Variable(interpolates, requires_grad=True) + + disc_interpolates = discriminator(interpolates) + gradients = autograd.grad( + outputs=disc_interpolates, + inputs=interpolates, + grad_outputs=torch.ones_like(disc_interpolates), + create_graph=True, + retain_graph=True, + only_inputs=True)[0] + + if weight is not None: + gradients = gradients * weight + + gradients_penalty = ((gradients.norm(2, dim=1) - 1)**2).mean() + if weight is not None: + gradients_penalty /= torch.mean(weight) + + return gradients_penalty + + +@LOSS_REGISTRY.register() +class GANFeatLoss(nn.Module): + """Define feature matching loss for gans + + Args: + criterion (str): Support 'l1', 'l2', 'charbonnier'. + loss_weight (float): Loss weight. Default: 1.0. + reduction (str): Specifies the reduction to apply to the output. + Supported choices are 'none' | 'mean' | 'sum'. Default: 'mean'. + """ + + def __init__(self, criterion='l1', loss_weight=1.0, reduction='mean'): + super(GANFeatLoss, self).__init__() + if criterion == 'l1': + self.loss_op = L1Loss(loss_weight, reduction) + elif criterion == 'l2': + self.loss_op = MSELoss(loss_weight, reduction) + elif criterion == 'charbonnier': + self.loss_op = CharbonnierLoss(loss_weight, reduction) + else: + raise ValueError(f'Unsupported loss mode: {criterion}. Supported ones are: l1|l2|charbonnier') + + self.loss_weight = loss_weight + + def forward(self, pred_fake, pred_real): + num_d = len(pred_fake) + loss = 0 + for i in range(num_d): # for each discriminator + # last output is the final prediction, exclude it + num_intermediate_outputs = len(pred_fake[i]) - 1 + for j in range(num_intermediate_outputs): # for each layer output + unweighted_loss = self.loss_op(pred_fake[i][j], pred_real[i][j].detach()) + loss += unweighted_loss / num_d + return loss * self.loss_weight + + +class sobel_loss(nn.Module): + def __init__(self, weight=1.0): + super().__init__() + kernel_x = torch.Tensor([[-1.0, 0.0, 1.0], [-2.0, 0.0, 2.0], [-1.0, 0.0, 1.0]]) + kernel_y = torch.Tensor([[-1.0, -2.0, -1.0], [0.0, 0.0, 0.0], [1.0, 2.0, 1.0]]) + kernel = torch.stack([kernel_x, kernel_y]) + kernel.requires_grad = False + kernel = kernel.unsqueeze(1) + self.register_buffer('sobel_kernel', kernel) + self.weight = weight + + def forward(self, input_tensor, target_tensor): + b, c, h, w = input_tensor.size() + input_tensor = input_tensor.view(b * c, 1, h, w) + input_edge = F.conv2d(input_tensor, self.sobel_kernel, padding=1) + input_edge = input_edge.view(b, 2*c, h, w) + + target_tensor = target_tensor.view(-1, 1, h, w) + target_edge = F.conv2d(target_tensor, self.sobel_kernel, padding=1) + target_edge = target_edge.view(b, 2*c, h, w) + + return self.weight * F.l1_loss(input_edge, target_edge) + + +@LOSS_REGISTRY.register() +class ColorfulnessLoss(nn.Module): + """Colorfulness loss. + + Args: + loss_weight (float): Loss weight for Colorfulness loss. Default: 1.0. + + """ + + def __init__(self, loss_weight=1.0): + super(ColorfulnessLoss, self).__init__() + + self.loss_weight = loss_weight + + def forward(self, pred, **kwargs): + """ + Args: + pred (Tensor): of shape (N, C, H, W). Predicted tensor. + """ + colorfulness_loss = 0 + for i in range(pred.shape[0]): + (R, G, B) = pred[i][0], pred[i][1], pred[i][2] + rg = torch.abs(R - G) + yb = torch.abs(0.5 * (R+G) - B) + (rbMean, rbStd) = (torch.mean(rg), torch.std(rg)) + (ybMean, ybStd) = (torch.mean(yb), torch.std(yb)) + stdRoot = torch.sqrt((rbStd ** 2) + (ybStd ** 2)) + meanRoot = torch.sqrt((rbMean ** 2) + (ybMean ** 2)) + colorfulness = stdRoot + (0.3 * meanRoot) + colorfulness_loss += (1 - colorfulness) + return self.loss_weight * colorfulness_loss diff --git a/basicsr/metrics/__init__.py b/basicsr/metrics/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..247dd10dea2b184275156adb8dc92a4b611da4cd --- /dev/null +++ b/basicsr/metrics/__init__.py @@ -0,0 +1,20 @@ +from copy import deepcopy + +from basicsr.utils.registry import METRIC_REGISTRY +from .psnr_ssim import calculate_psnr, calculate_ssim +from .colorfulness import calculate_cf + +__all__ = ['calculate_psnr', 'calculate_ssim', 'calculate_cf'] + + +def calculate_metric(data, opt): + """Calculate metric from data and options. + + Args: + opt (dict): Configuration. It must contain: + type (str): Model type. + """ + opt = deepcopy(opt) + metric_type = opt.pop('type') + metric = METRIC_REGISTRY.get(metric_type)(**data, **opt) + return metric diff --git a/basicsr/metrics/colorfulness.py b/basicsr/metrics/colorfulness.py new file mode 100644 index 0000000000000000000000000000000000000000..a2ee6537c0119ec5576f0cf4898b10351b7a2a49 --- /dev/null +++ b/basicsr/metrics/colorfulness.py @@ -0,0 +1,17 @@ +import cv2 +import numpy as np +from basicsr.utils.registry import METRIC_REGISTRY + + +@METRIC_REGISTRY.register() +def calculate_cf(img, **kwargs): + """Calculate Colorfulness. + """ + (B, G, R) = cv2.split(img.astype('float')) + rg = np.absolute(R - G) + yb = np.absolute(0.5 * (R+G) - B) + (rbMean, rbStd) = (np.mean(rg), np.std(rg)) + (ybMean, ybStd) = (np.mean(yb), np.std(yb)) + stdRoot = np.sqrt((rbStd ** 2) + (ybStd ** 2)) + meanRoot = np.sqrt((rbMean ** 2) + (ybMean ** 2)) + return stdRoot + (0.3 * meanRoot) diff --git a/basicsr/metrics/custom_fid.py b/basicsr/metrics/custom_fid.py new file mode 100644 index 0000000000000000000000000000000000000000..4fe19a19be486ac0b38e726438281534280ade5f --- /dev/null +++ b/basicsr/metrics/custom_fid.py @@ -0,0 +1,260 @@ +import numpy as np +import torch.nn.functional as F +from scipy import linalg +import torch.nn as nn +from torchvision import models + + +class INCEPTION_V3_FID(nn.Module): + """pretrained InceptionV3 network returning feature maps""" + # Index of default block of inception to return, + # corresponds to output of final average pooling + DEFAULT_BLOCK_INDEX = 3 + + # Maps feature dimensionality to their output blocks indices + BLOCK_INDEX_BY_DIM = { + 64: 0, # First max pooling features + 192: 1, # Second max pooling featurs + 768: 2, # Pre-aux classifier features + 2048: 3 # Final average pooling features + } + + def __init__(self, + incep_state_dict, + output_blocks=[DEFAULT_BLOCK_INDEX], + resize_input=True): + """Build pretrained InceptionV3 + Parameters + ---------- + output_blocks : list of int + Indices of blocks to return features of. Possible values are: + - 0: corresponds to output of first max pooling + - 1: corresponds to output of second max pooling + - 2: corresponds to output which is fed to aux classifier + - 3: corresponds to output of final average pooling + resize_input : bool + If true, bilinearly resizes input to width and height 299 before + feeding input to model. As the network without fully connected + layers is fully convolutional, it should be able to handle inputs + of arbitrary size, so resizing might not be strictly needed + normalize_input : bool + If true, normalizes the input to the statistics the pretrained + Inception network expects + """ + super(INCEPTION_V3_FID, self).__init__() + + self.resize_input = resize_input + self.output_blocks = sorted(output_blocks) + self.last_needed_block = max(output_blocks) + + assert self.last_needed_block <= 3, \ + 'Last possible output block index is 3' + + self.blocks = nn.ModuleList() + + inception = models.inception_v3() + inception.load_state_dict(incep_state_dict) + for param in inception.parameters(): + param.requires_grad = False + + # Block 0: input to maxpool1 + block0 = [ + inception.Conv2d_1a_3x3, + inception.Conv2d_2a_3x3, + inception.Conv2d_2b_3x3, + nn.MaxPool2d(kernel_size=3, stride=2) + ] + self.blocks.append(nn.Sequential(*block0)) + + # Block 1: maxpool1 to maxpool2 + if self.last_needed_block >= 1: + block1 = [ + inception.Conv2d_3b_1x1, + inception.Conv2d_4a_3x3, + nn.MaxPool2d(kernel_size=3, stride=2) + ] + self.blocks.append(nn.Sequential(*block1)) + + # Block 2: maxpool2 to aux classifier + if self.last_needed_block >= 2: + block2 = [ + inception.Mixed_5b, + inception.Mixed_5c, + inception.Mixed_5d, + inception.Mixed_6a, + inception.Mixed_6b, + inception.Mixed_6c, + inception.Mixed_6d, + inception.Mixed_6e, + ] + self.blocks.append(nn.Sequential(*block2)) + + # Block 3: aux classifier to final avgpool + if self.last_needed_block >= 3: + block3 = [ + inception.Mixed_7a, + inception.Mixed_7b, + inception.Mixed_7c, + nn.AdaptiveAvgPool2d(output_size=(1, 1)) + ] + self.blocks.append(nn.Sequential(*block3)) + + def forward(self, inp): + """Get Inception feature maps + Parameters + ---------- + inp : torch.autograd.Variable + Input tensor of shape Bx3xHxW. Values are expected to be in + range (0, 1) + Returns + ------- + List of torch.autograd.Variable, corresponding to the selected output + block, sorted ascending by index + """ + outp = [] + x = inp + + if self.resize_input: + x = F.interpolate(x, size=(299, 299), mode='bilinear') + + x = x.clone() + # [-1.0, 1.0] --> [0, 1.0] + x = x * 0.5 + 0.5 + x[:, 0] = x[:, 0] * (0.229 / 0.5) + (0.485 - 0.5) / 0.5 + x[:, 1] = x[:, 1] * (0.224 / 0.5) + (0.456 - 0.5) / 0.5 + x[:, 2] = x[:, 2] * (0.225 / 0.5) + (0.406 - 0.5) / 0.5 + + for idx, block in enumerate(self.blocks): + x = block(x) + if idx in self.output_blocks: + outp.append(x) + + if idx == self.last_needed_block: + break + + return outp + + +def get_activations(images, model, batch_size, verbose=False): + """Calculates the activations of the pool_3 layer for all images. + Params: + -- images : Numpy array of dimension (n_images, 3, hi, wi). The values + must lie between 0 and 1. + -- model : Instance of inception model + -- batch_size : the images numpy array is split into batches with + batch size batch_size. A reasonable batch size depends + on the hardware. + -- verbose : If set to True and parameter out_step is given, the number + of calculated batches is reported. + Returns: + -- A numpy array of dimension (num images, dims) that contains the + activations of the given tensor when feeding inception with the + query tensor. + """ + model.eval() + + #d0 = images.shape[0] + d0 = int(images.size(0)) + if batch_size > d0: + print(('Warning: batch size is bigger than the data size. ' + 'Setting batch size to data size')) + batch_size = d0 + + n_batches = d0 // batch_size + n_used_imgs = n_batches * batch_size + + pred_arr = np.empty((n_used_imgs, 2048)) + for i in range(n_batches): + if verbose: + print('\rPropagating batch %d/%d' % (i + 1, n_batches), end='', flush=True) + start = i * batch_size + end = start + batch_size + + '''batch = torch.from_numpy(images[start:end]).type(torch.FloatTensor) + batch = Variable(batch, volatile=True) + if cfg.CUDA: + batch = batch.cuda()''' + batch = images[start:end] + + pred = model(batch)[0] + + # If model output is not scalar, apply global spatial average pooling. + # This happens if you choose a dimensionality not equal 2048. + if pred.shape[2] != 1 or pred.shape[3] != 1: + pred = F.adaptive_avg_pool2d(pred, output_size=(1, 1)) + + pred_arr[start:end] = pred.cpu().data.numpy().reshape(batch_size, -1) + + if verbose: + print(' done') + + return pred_arr + + +def calculate_activation_statistics(act): + """Calculation of the statistics used by the FID. + Params: + -- act : Numpy array of dimension (n_images, dim (e.g. 2048)). + Returns: + -- mu : The mean over samples of the activations of the pool_3 layer of + the inception model. + -- sigma : The covariance matrix of the activations of the pool_3 layer of + the inception model. + """ + mu = np.mean(act, axis=0) + sigma = np.cov(act, rowvar=False) + return mu, sigma + + +def calculate_frechet_distance(mu1, sigma1, mu2, sigma2, eps=1e-6): + """Numpy implementation of the Frechet Distance. + The Frechet distance between two multivariate Gaussians X_1 ~ N(mu_1, C_1) + and X_2 ~ N(mu_2, C_2) is + d^2 = ||mu_1 - mu_2||^2 + Tr(C_1 + C_2 - 2*sqrt(C_1*C_2)). + Stable version by Dougal J. Sutherland. + Params: + -- mu1 : Numpy array containing the activations of a layer of the + inception net (like returned by the function 'get_predictions') + for generated samples. + -- mu2 : The sample mean over activations, precalculated on an + representive data set. + -- sigma1: The covariance matrix over activations for generated samples. + -- sigma2: The covariance matrix over activations, precalculated on an + representive data set. + Returns: + -- : The Frechet Distance. + """ + + mu1 = np.atleast_1d(mu1) + mu2 = np.atleast_1d(mu2) + + sigma1 = np.atleast_2d(sigma1) + sigma2 = np.atleast_2d(sigma2) + + assert mu1.shape == mu2.shape, \ + 'Training and test mean vectors have different lengths' + assert sigma1.shape == sigma2.shape, \ + 'Training and test covariances have different dimensions' + + diff = mu1 - mu2 + + # Product might be almost singular + covmean, _ = linalg.sqrtm(sigma1.dot(sigma2), disp=False) + if not np.isfinite(covmean).all(): + msg = ('fid calculation produces singular product; ' + 'adding %s to diagonal of cov estimates') % eps + print(msg) + offset = np.eye(sigma1.shape[0]) * eps + covmean = linalg.sqrtm((sigma1 + offset).dot(sigma2 + offset)) + + # Numerical error might give slight imaginary component + if np.iscomplexobj(covmean): + if not np.allclose(np.diagonal(covmean).imag, 0, atol=1e-3): + m = np.max(np.abs(covmean.imag)) + raise ValueError('Imaginary component {}'.format(m)) + covmean = covmean.real + + tr_covmean = np.trace(covmean) + + return (diff.dot(diff) + np.trace(sigma1) + + np.trace(sigma2) - 2 * tr_covmean) diff --git a/basicsr/metrics/metric_util.py b/basicsr/metrics/metric_util.py new file mode 100644 index 0000000000000000000000000000000000000000..4d18f0f7816431bed6af9d58319c6435bdf5c971 --- /dev/null +++ b/basicsr/metrics/metric_util.py @@ -0,0 +1,45 @@ +import numpy as np + +from basicsr.utils.matlab_functions import bgr2ycbcr + + +def reorder_image(img, input_order='HWC'): + """Reorder images to 'HWC' order. + + If the input_order is (h, w), return (h, w, 1); + If the input_order is (c, h, w), return (h, w, c); + If the input_order is (h, w, c), return as it is. + + Args: + img (ndarray): Input image. + input_order (str): Whether the input order is 'HWC' or 'CHW'. + If the input image shape is (h, w), input_order will not have + effects. Default: 'HWC'. + + Returns: + ndarray: reordered image. + """ + + if input_order not in ['HWC', 'CHW']: + raise ValueError(f'Wrong input_order {input_order}. Supported input_orders are ' "'HWC' and 'CHW'") + if len(img.shape) == 2: + img = img[..., None] + if input_order == 'CHW': + img = img.transpose(1, 2, 0) + return img + + +def to_y_channel(img): + """Change to Y channel of YCbCr. + + Args: + img (ndarray): Images with range [0, 255]. + + Returns: + (ndarray): Images with range [0, 255] (float type) without round. + """ + img = img.astype(np.float32) / 255. + if img.ndim == 3 and img.shape[2] == 3: + img = bgr2ycbcr(img, y_only=True) + img = img[..., None] + return img * 255. diff --git a/basicsr/metrics/psnr_ssim.py b/basicsr/metrics/psnr_ssim.py new file mode 100644 index 0000000000000000000000000000000000000000..241d04d210ebfe97319461f33a0e7341b60b295d --- /dev/null +++ b/basicsr/metrics/psnr_ssim.py @@ -0,0 +1,128 @@ +import cv2 +import numpy as np + +from basicsr.metrics.metric_util import reorder_image, to_y_channel +from basicsr.utils.registry import METRIC_REGISTRY + + +@METRIC_REGISTRY.register() +def calculate_psnr(img, img2, crop_border, input_order='HWC', test_y_channel=False, **kwargs): + """Calculate PSNR (Peak Signal-to-Noise Ratio). + + Ref: https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio + + Args: + img (ndarray): Images with range [0, 255]. + img2 (ndarray): Images with range [0, 255]. + crop_border (int): Cropped pixels in each edge of an image. These + pixels are not involved in the PSNR calculation. + input_order (str): Whether the input order is 'HWC' or 'CHW'. + Default: 'HWC'. + test_y_channel (bool): Test on Y channel of YCbCr. Default: False. + + Returns: + float: psnr result. + """ + + assert img.shape == img2.shape, (f'Image shapes are different: {img.shape}, {img2.shape}.') + if input_order not in ['HWC', 'CHW']: + raise ValueError(f'Wrong input_order {input_order}. Supported input_orders are ' '"HWC" and "CHW"') + img = reorder_image(img, input_order=input_order) + img2 = reorder_image(img2, input_order=input_order) + img = img.astype(np.float64) + img2 = img2.astype(np.float64) + + if crop_border != 0: + img = img[crop_border:-crop_border, crop_border:-crop_border, ...] + img2 = img2[crop_border:-crop_border, crop_border:-crop_border, ...] + + if test_y_channel: + img = to_y_channel(img) + img2 = to_y_channel(img2) + + mse = np.mean((img - img2)**2) + if mse == 0: + return float('inf') + return 20. * np.log10(255. / np.sqrt(mse)) + + +def _ssim(img, img2): + """Calculate SSIM (structural similarity) for one channel images. + + It is called by func:`calculate_ssim`. + + Args: + img (ndarray): Images with range [0, 255] with order 'HWC'. + img2 (ndarray): Images with range [0, 255] with order 'HWC'. + + Returns: + float: ssim result. + """ + + c1 = (0.01 * 255)**2 + c2 = (0.03 * 255)**2 + + img = img.astype(np.float64) + img2 = img2.astype(np.float64) + kernel = cv2.getGaussianKernel(11, 1.5) + window = np.outer(kernel, kernel.transpose()) + + mu1 = cv2.filter2D(img, -1, window)[5:-5, 5:-5] + mu2 = cv2.filter2D(img2, -1, window)[5:-5, 5:-5] + mu1_sq = mu1**2 + mu2_sq = mu2**2 + mu1_mu2 = mu1 * mu2 + sigma1_sq = cv2.filter2D(img**2, -1, window)[5:-5, 5:-5] - mu1_sq + sigma2_sq = cv2.filter2D(img2**2, -1, window)[5:-5, 5:-5] - mu2_sq + sigma12 = cv2.filter2D(img * img2, -1, window)[5:-5, 5:-5] - mu1_mu2 + + ssim_map = ((2 * mu1_mu2 + c1) * (2 * sigma12 + c2)) / ((mu1_sq + mu2_sq + c1) * (sigma1_sq + sigma2_sq + c2)) + return ssim_map.mean() + + +@METRIC_REGISTRY.register() +def calculate_ssim(img, img2, crop_border, input_order='HWC', test_y_channel=False, **kwargs): + """Calculate SSIM (structural similarity). + + Ref: + Image quality assessment: From error visibility to structural similarity + + The results are the same as that of the official released MATLAB code in + https://ece.uwaterloo.ca/~z70wang/research/ssim/. + + For three-channel images, SSIM is calculated for each channel and then + averaged. + + Args: + img (ndarray): Images with range [0, 255]. + img2 (ndarray): Images with range [0, 255]. + crop_border (int): Cropped pixels in each edge of an image. These + pixels are not involved in the SSIM calculation. + input_order (str): Whether the input order is 'HWC' or 'CHW'. + Default: 'HWC'. + test_y_channel (bool): Test on Y channel of YCbCr. Default: False. + + Returns: + float: ssim result. + """ + + assert img.shape == img2.shape, (f'Image shapes are different: {img.shape}, {img2.shape}.') + if input_order not in ['HWC', 'CHW']: + raise ValueError(f'Wrong input_order {input_order}. Supported input_orders are ' '"HWC" and "CHW"') + img = reorder_image(img, input_order=input_order) + img2 = reorder_image(img2, input_order=input_order) + img = img.astype(np.float64) + img2 = img2.astype(np.float64) + + if crop_border != 0: + img = img[crop_border:-crop_border, crop_border:-crop_border, ...] + img2 = img2[crop_border:-crop_border, crop_border:-crop_border, ...] + + if test_y_channel: + img = to_y_channel(img) + img2 = to_y_channel(img2) + + ssims = [] + for i in range(img.shape[2]): + ssims.append(_ssim(img[..., i], img2[..., i])) + return np.array(ssims).mean() diff --git a/basicsr/models/__init__.py b/basicsr/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..285ce3ef90550f5cd6cb61467388f8ae4b73f14a --- /dev/null +++ b/basicsr/models/__init__.py @@ -0,0 +1,30 @@ +import importlib +from copy import deepcopy +from os import path as osp + +from basicsr.utils import get_root_logger, scandir +from basicsr.utils.registry import MODEL_REGISTRY + +__all__ = ['build_model'] + +# automatically scan and import model modules for registry +# scan all the files under the 'models' folder and collect files ending with +# '_model.py' +model_folder = osp.dirname(osp.abspath(__file__)) +model_filenames = [osp.splitext(osp.basename(v))[0] for v in scandir(model_folder) if v.endswith('_model.py')] +# import all the model modules +_model_modules = [importlib.import_module(f'basicsr.models.{file_name}') for file_name in model_filenames] + + +def build_model(opt): + """Build model from options. + + Args: + opt (dict): Configuration. It must contain: + model_type (str): Model type. + """ + opt = deepcopy(opt) + model = MODEL_REGISTRY.get(opt['model_type'])(opt) + logger = get_root_logger() + logger.info(f'Model [{model.__class__.__name__}] is created.') + return model diff --git a/basicsr/models/base_model.py b/basicsr/models/base_model.py new file mode 100644 index 0000000000000000000000000000000000000000..d662195db4634fc4a45407588e23935df3df6527 --- /dev/null +++ b/basicsr/models/base_model.py @@ -0,0 +1,382 @@ +import os +import time +import torch +from collections import OrderedDict +from copy import deepcopy +from torch.nn.parallel import DataParallel, DistributedDataParallel + +from basicsr.models import lr_scheduler as lr_scheduler +from basicsr.utils import get_root_logger +from basicsr.utils.dist_util import master_only + + +class BaseModel(): + """Base model.""" + + def __init__(self, opt): + self.opt = opt + self.device = torch.device('cuda' if opt['num_gpu'] != 0 else 'cpu') + self.is_train = opt['is_train'] + self.schedulers = [] + self.optimizers = [] + + def feed_data(self, data): + pass + + def optimize_parameters(self): + pass + + def get_current_visuals(self): + pass + + def save(self, epoch, current_iter): + """Save networks and training state.""" + pass + + def validation(self, dataloader, current_iter, tb_logger, save_img=False): + """Validation function. + + Args: + dataloader (torch.utils.data.DataLoader): Validation dataloader. + current_iter (int): Current iteration. + tb_logger (tensorboard logger): Tensorboard logger. + save_img (bool): Whether to save images. Default: False. + """ + if self.opt['dist']: + self.dist_validation(dataloader, current_iter, tb_logger, save_img) + else: + self.nondist_validation(dataloader, current_iter, tb_logger, save_img) + + def _initialize_best_metric_results(self, dataset_name): + """Initialize the best metric results dict for recording the best metric value and iteration.""" + if hasattr(self, 'best_metric_results') and dataset_name in self.best_metric_results: + return + elif not hasattr(self, 'best_metric_results'): + self.best_metric_results = dict() + + # add a dataset record + record = dict() + for metric, content in self.opt['val']['metrics'].items(): + better = content.get('better', 'higher') + init_val = float('-inf') if better == 'higher' else float('inf') + record[metric] = dict(better=better, val=init_val, iter=-1) + self.best_metric_results[dataset_name] = record + + def _update_best_metric_result(self, dataset_name, metric, val, current_iter): + if self.best_metric_results[dataset_name][metric]['better'] == 'higher': + if val >= self.best_metric_results[dataset_name][metric]['val']: + self.best_metric_results[dataset_name][metric]['val'] = val + self.best_metric_results[dataset_name][metric]['iter'] = current_iter + else: + if val <= self.best_metric_results[dataset_name][metric]['val']: + self.best_metric_results[dataset_name][metric]['val'] = val + self.best_metric_results[dataset_name][metric]['iter'] = current_iter + + def model_ema(self, decay=0.999): + net_g = self.get_bare_model(self.net_g) + + net_g_params = dict(net_g.named_parameters()) + net_g_ema_params = dict(self.net_g_ema.named_parameters()) + + for k in net_g_ema_params.keys(): + net_g_ema_params[k].data.mul_(decay).add_(net_g_params[k].data, alpha=1 - decay) + + def get_current_log(self): + return self.log_dict + + def model_to_device(self, net): + """Model to device. It also warps models with DistributedDataParallel + or DataParallel. + + Args: + net (nn.Module) + """ + net = net.to(self.device) + if self.opt['dist']: + find_unused_parameters = self.opt.get('find_unused_parameters', False) + net = DistributedDataParallel( + net, device_ids=[torch.cuda.current_device()], find_unused_parameters=find_unused_parameters) + elif self.opt['num_gpu'] > 1: + net = DataParallel(net) + return net + + def get_optimizer(self, optim_type, params, lr, **kwargs): + if optim_type == 'Adam': + optimizer = torch.optim.Adam(params, lr, **kwargs) + elif optim_type == 'AdamW': + optimizer = torch.optim.AdamW(params, lr, **kwargs) + else: + raise NotImplementedError(f'optimizer {optim_type} is not supperted yet.') + return optimizer + + def setup_schedulers(self): + """Set up schedulers.""" + train_opt = self.opt['train'] + scheduler_type = train_opt['scheduler'].pop('type') + if scheduler_type in ['MultiStepLR', 'MultiStepRestartLR']: + for optimizer in self.optimizers: + self.schedulers.append(lr_scheduler.MultiStepRestartLR(optimizer, **train_opt['scheduler'])) + elif scheduler_type == 'CosineAnnealingRestartLR': + for optimizer in self.optimizers: + self.schedulers.append(lr_scheduler.CosineAnnealingRestartLR(optimizer, **train_opt['scheduler'])) + else: + raise NotImplementedError(f'Scheduler {scheduler_type} is not implemented yet.') + + def get_bare_model(self, net): + """Get bare model, especially under wrapping with + DistributedDataParallel or DataParallel. + """ + if isinstance(net, (DataParallel, DistributedDataParallel)): + net = net.module + return net + + @master_only + def print_network(self, net): + """Print the str and parameter number of a network. + + Args: + net (nn.Module) + """ + if isinstance(net, (DataParallel, DistributedDataParallel)): + net_cls_str = f'{net.__class__.__name__} - {net.module.__class__.__name__}' + else: + net_cls_str = f'{net.__class__.__name__}' + + net = self.get_bare_model(net) + net_str = str(net) + net_params = sum(map(lambda x: x.numel(), net.parameters())) + + logger = get_root_logger() + logger.info(f'Network: {net_cls_str}, with parameters: {net_params:,d}') + logger.info(net_str) + + def _set_lr(self, lr_groups_l): + """Set learning rate for warmup. + + Args: + lr_groups_l (list): List for lr_groups, each for an optimizer. + """ + for optimizer, lr_groups in zip(self.optimizers, lr_groups_l): + for param_group, lr in zip(optimizer.param_groups, lr_groups): + param_group['lr'] = lr + + def _get_init_lr(self): + """Get the initial lr, which is set by the scheduler. + """ + init_lr_groups_l = [] + for optimizer in self.optimizers: + init_lr_groups_l.append([v['initial_lr'] for v in optimizer.param_groups]) + return init_lr_groups_l + + def update_learning_rate(self, current_iter, warmup_iter=-1): + """Update learning rate. + + Args: + current_iter (int): Current iteration. + warmup_iter (int)： Warmup iter numbers. -1 for no warmup. + Default： -1. + """ + if current_iter > 1: + for scheduler in self.schedulers: + scheduler.step() + # set up warm-up learning rate + if current_iter < warmup_iter: + # get initial lr for each group + init_lr_g_l = self._get_init_lr() + # modify warming-up learning rates + # currently only support linearly warm up + warm_up_lr_l = [] + for init_lr_g in init_lr_g_l: + warm_up_lr_l.append([v / warmup_iter * current_iter for v in init_lr_g]) + # set learning rate + self._set_lr(warm_up_lr_l) + + def get_current_learning_rate(self): + return [param_group['lr'] for param_group in self.optimizers[0].param_groups] + + @master_only + def save_network(self, net, net_label, current_iter, param_key='params'): + """Save networks. + + Args: + net (nn.Module | list[nn.Module]): Network(s) to be saved. + net_label (str): Network label. + current_iter (int): Current iter number. + param_key (str | list[str]): The parameter key(s) to save network. + Default: 'params'. + """ + if current_iter == -1: + current_iter = 'latest' + save_filename = f'{net_label}_{current_iter}.pth' + save_path = os.path.join(self.opt['path']['models'], save_filename) + + net = net if isinstance(net, list) else [net] + param_key = param_key if isinstance(param_key, list) else [param_key] + assert len(net) == len(param_key), 'The lengths of net and param_key should be the same.' + + save_dict = {} + for net_, param_key_ in zip(net, param_key): + net_ = self.get_bare_model(net_) + state_dict = net_.state_dict() + for key, param in state_dict.items(): + if key.startswith('module.'): # remove unnecessary 'module.' + key = key[7:] + state_dict[key] = param.cpu() + save_dict[param_key_] = state_dict + + # avoid occasional writing errors + retry = 3 + while retry > 0: + try: + torch.save(save_dict, save_path) + except Exception as e: + logger = get_root_logger() + logger.warning(f'Save model error: {e}, remaining retry times: {retry - 1}') + time.sleep(1) + else: + break + finally: + retry -= 1 + if retry == 0: + logger.warning(f'Still cannot save {save_path}. Just ignore it.') + # raise IOError(f'Cannot save {save_path}.') + + def _print_different_keys_loading(self, crt_net, load_net, strict=True): + """Print keys with different name or different size when loading models. + + 1. Print keys with different names. + 2. If strict=False, print the same key but with different tensor size. + It also ignore these keys with different sizes (not load). + + Args: + crt_net (torch model): Current network. + load_net (dict): Loaded network. + strict (bool): Whether strictly loaded. Default: True. + """ + crt_net = self.get_bare_model(crt_net) + crt_net = crt_net.state_dict() + crt_net_keys = set(crt_net.keys()) + load_net_keys = set(load_net.keys()) + + logger = get_root_logger() + if crt_net_keys != load_net_keys: + logger.warning('Current net - loaded net:') + for v in sorted(list(crt_net_keys - load_net_keys)): + logger.warning(f' {v}') + logger.warning('Loaded net - current net:') + for v in sorted(list(load_net_keys - crt_net_keys)): + logger.warning(f' {v}') + + # check the size for the same keys + if not strict: + common_keys = crt_net_keys & load_net_keys + for k in common_keys: + if crt_net[k].size() != load_net[k].size(): + logger.warning(f'Size different, ignore [{k}]: crt_net: ' + f'{crt_net[k].shape}; load_net: {load_net[k].shape}') + load_net[k + '.ignore'] = load_net.pop(k) + + def load_network(self, net, load_path, strict=True, param_key='params'): + """Load network. + + Args: + load_path (str): The path of networks to be loaded. + net (nn.Module): Network. + strict (bool): Whether strictly loaded. + param_key (str): The parameter key of loaded network. If set to + None, use the root 'path'. + Default: 'params'. + """ + logger = get_root_logger() + net = self.get_bare_model(net) + load_net = torch.load(load_path, map_location=lambda storage, loc: storage) + if param_key is not None: + if param_key not in load_net and 'params' in load_net: + param_key = 'params' + logger.info('Loading: params_ema does not exist, use params.') + load_net = load_net[param_key] + logger.info(f'Loading {net.__class__.__name__} model from {load_path}, with param key: [{param_key}].') + # remove unnecessary 'module.' + for k, v in deepcopy(load_net).items(): + if k.startswith('module.'): + load_net[k[7:]] = v + load_net.pop(k) + self._print_different_keys_loading(net, load_net, strict) + net.load_state_dict(load_net, strict=strict) + + @master_only + def save_training_state(self, epoch, current_iter): + """Save training states during training, which will be used for + resuming. + + Args: + epoch (int): Current epoch. + current_iter (int): Current iteration. + """ + if current_iter != -1: + state = {'epoch': epoch, 'iter': current_iter, 'optimizers': [], 'schedulers': []} + for o in self.optimizers: + state['optimizers'].append(o.state_dict()) + for s in self.schedulers: + state['schedulers'].append(s.state_dict()) + save_filename = f'{current_iter}.state' + save_path = os.path.join(self.opt['path']['training_states'], save_filename) + + # avoid occasional writing errors + retry = 3 + while retry > 0: + try: + torch.save(state, save_path) + except Exception as e: + logger = get_root_logger() + logger.warning(f'Save training state error: {e}, remaining retry times: {retry - 1}') + time.sleep(1) + else: + break + finally: + retry -= 1 + if retry == 0: + logger.warning(f'Still cannot save {save_path}. Just ignore it.') + # raise IOError(f'Cannot save {save_path}.') + + def resume_training(self, resume_state): + """Reload the optimizers and schedulers for resumed training. + + Args: + resume_state (dict): Resume state. + """ + resume_optimizers = resume_state['optimizers'] + resume_schedulers = resume_state['schedulers'] + assert len(resume_optimizers) == len(self.optimizers), 'Wrong lengths of optimizers' + assert len(resume_schedulers) == len(self.schedulers), 'Wrong lengths of schedulers' + for i, o in enumerate(resume_optimizers): + self.optimizers[i].load_state_dict(o) + for i, s in enumerate(resume_schedulers): + self.schedulers[i].load_state_dict(s) + + def reduce_loss_dict(self, loss_dict): + """reduce loss dict. + + In distributed training, it averages the losses among different GPUs . + + Args: + loss_dict (OrderedDict): Loss dict. + """ + with torch.no_grad(): + if self.opt['dist']: + keys = [] + losses = [] + for name, value in loss_dict.items(): + keys.append(name) + losses.append(value) + losses = torch.stack(losses, 0) + torch.distributed.reduce(losses, dst=0) + if self.opt['rank'] == 0: + losses /= self.opt['world_size'] + loss_dict = {key: loss for key, loss in zip(keys, losses)} + + log_dict = OrderedDict() + for name, value in loss_dict.items(): + log_dict[name] = value.mean().item() + + return log_dict diff --git a/basicsr/models/color_model.py b/basicsr/models/color_model.py new file mode 100644 index 0000000000000000000000000000000000000000..bd02b171c64e81c725a8071e357b7486f0015b3b --- /dev/null +++ b/basicsr/models/color_model.py @@ -0,0 +1,369 @@ +import os +import torch +from collections import OrderedDict +from os import path as osp +from tqdm import tqdm +import numpy as np + +from basicsr.archs import build_network +from basicsr.losses import build_loss +from basicsr.metrics import calculate_metric +from basicsr.utils import get_root_logger, imwrite, tensor2img +from basicsr.utils.img_util import tensor_lab2rgb +from basicsr.utils.dist_util import master_only +from basicsr.utils.registry import MODEL_REGISTRY +from .base_model import BaseModel +from basicsr.metrics.custom_fid import INCEPTION_V3_FID, get_activations, calculate_activation_statistics, calculate_frechet_distance +from basicsr.utils.color_enhance import color_enhacne_blend + + +@MODEL_REGISTRY.register() +class ColorModel(BaseModel): + """Colorization model for single image colorization.""" + + def __init__(self, opt): + super(ColorModel, self).__init__(opt) + + # define network net_g + self.net_g = build_network(opt['network_g']) + self.net_g = self.model_to_device(self.net_g) + self.print_network(self.net_g) + + # load pretrained model for net_g + load_path = self.opt['path'].get('pretrain_network_g', None) + if load_path is not None: + param_key = self.opt['path'].get('param_key_g', 'params') + self.load_network(self.net_g, load_path, self.opt['path'].get('strict_load_g', True), param_key) + + if self.is_train: + self.init_training_settings() + + def init_training_settings(self): + train_opt = self.opt['train'] + + self.ema_decay = train_opt.get('ema_decay', 0) + if self.ema_decay > 0: + logger = get_root_logger() + logger.info(f'Use Exponential Moving Average with decay: {self.ema_decay}') + # define network net_g with Exponential Moving Average (EMA) + # net_g_ema is used only for testing on one GPU and saving + # There is no need to wrap with DistributedDataParallel + self.net_g_ema = build_network(self.opt['network_g']).to(self.device) + # load pretrained model + load_path = self.opt['path'].get('pretrain_network_g', None) + if load_path is not None: + self.load_network(self.net_g_ema, load_path, self.opt['path'].get('strict_load_g', True), 'params_ema') + else: + self.model_ema(0) # copy net_g weight + self.net_g_ema.eval() + + # define network net_d + self.net_d = build_network(self.opt['network_d']) + self.net_d = self.model_to_device(self.net_d) + self.print_network(self.net_d) + + # load pretrained model for net_d + load_path = self.opt['path'].get('pretrain_network_d', None) + if load_path is not None: + param_key = self.opt['path'].get('param_key_d', 'params') + self.load_network(self.net_d, load_path, self.opt['path'].get('strict_load_d', True), param_key) + + self.net_g.train() + self.net_d.train() + + # define losses + if train_opt.get('pixel_opt'): + self.cri_pix = build_loss(train_opt['pixel_opt']).to(self.device) + else: + self.cri_pix = None + + if train_opt.get('perceptual_opt'): + self.cri_perceptual = build_loss(train_opt['perceptual_opt']).to(self.device) + else: + self.cri_perceptual = None + + if train_opt.get('gan_opt'): + self.cri_gan = build_loss(train_opt['gan_opt']).to(self.device) + else: + self.cri_gan = None + + if self.cri_pix is None and self.cri_perceptual is None: + raise ValueError('Both pixel and perceptual losses are None.') + + if train_opt.get('colorfulness_opt'): + self.cri_colorfulness = build_loss(train_opt['colorfulness_opt']).to(self.device) + else: + self.cri_colorfulness = None + + # set up optimizers and schedulers + self.setup_optimizers() + self.setup_schedulers() + + # set real dataset cache for fid metric computing + self.real_mu, self.real_sigma = None, None + if self.opt['val'].get('metrics') is not None and self.opt['val']['metrics'].get('fid') is not None: + self._prepare_inception_model_fid() + + def setup_optimizers(self): + train_opt = self.opt['train'] + # optim_params_g = [] + # for k, v in self.net_g.named_parameters(): + # if v.requires_grad: + # optim_params_g.append(v) + # else: + # logger = get_root_logger() + # logger.warning(f'Params {k} will not be optimized.') + optim_params_g = self.net_g.parameters() + + # optimizer g + optim_type = train_opt['optim_g'].pop('type') + self.optimizer_g = self.get_optimizer(optim_type, optim_params_g, **train_opt['optim_g']) + self.optimizers.append(self.optimizer_g) + + # optimizer d + optim_type = train_opt['optim_d'].pop('type') + self.optimizer_d = self.get_optimizer(optim_type, self.net_d.parameters(), **train_opt['optim_d']) + self.optimizers.append(self.optimizer_d) + + def feed_data(self, data): + self.lq = data['lq'].to(self.device) + self.lq_rgb = tensor_lab2rgb(torch.cat([self.lq, torch.zeros_like(self.lq), torch.zeros_like(self.lq)], dim=1)) + if 'gt' in data: + self.gt = data['gt'].to(self.device) + self.gt_lab = torch.cat([self.lq, self.gt], dim=1) + self.gt_rgb = tensor_lab2rgb(self.gt_lab) + + if self.opt['train'].get('color_enhance', False): + for i in range(self.gt_rgb.shape[0]): + self.gt_rgb[i] = color_enhacne_blend(self.gt_rgb[i], factor=self.opt['train'].get('color_enhance_factor')) + + def optimize_parameters(self, current_iter): + # optimize net_g + for p in self.net_d.parameters(): + p.requires_grad = False + self.optimizer_g.zero_grad() + + self.output_ab = self.net_g(self.lq_rgb) + self.output_lab = torch.cat([self.lq, self.output_ab], dim=1) + self.output_rgb = tensor_lab2rgb(self.output_lab) + + l_g_total = 0 + loss_dict = OrderedDict() + # pixel loss + if self.cri_pix: + l_g_pix = self.cri_pix(self.output_ab, self.gt) + l_g_total += l_g_pix + loss_dict['l_g_pix'] = l_g_pix + + # perceptual loss + if self.cri_perceptual: + l_g_percep, l_g_style = self.cri_perceptual(self.output_rgb, self.gt_rgb) + if l_g_percep is not None: + l_g_total += l_g_percep + loss_dict['l_g_percep'] = l_g_percep + if l_g_style is not None: + l_g_total += l_g_style + loss_dict['l_g_style'] = l_g_style + # gan loss + if self.cri_gan: + fake_g_pred = self.net_d(self.output_rgb) + l_g_gan = self.cri_gan(fake_g_pred, target_is_real=True, is_disc=False) + l_g_total += l_g_gan + loss_dict['l_g_gan'] = l_g_gan + # colorfulness loss + if self.cri_colorfulness: + l_g_color = self.cri_colorfulness(self.output_rgb) + l_g_total += l_g_color + loss_dict['l_g_color'] = l_g_color + + l_g_total.backward() + self.optimizer_g.step() + + # optimize net_d + for p in self.net_d.parameters(): + p.requires_grad = True + self.optimizer_d.zero_grad() + + real_d_pred = self.net_d(self.gt_rgb) + fake_d_pred = self.net_d(self.output_rgb.detach()) + l_d = self.cri_gan(real_d_pred, target_is_real=True, is_disc=True) + self.cri_gan(fake_d_pred, target_is_real=False, is_disc=True) + loss_dict['l_d'] = l_d + loss_dict['real_score'] = real_d_pred.detach().mean() + loss_dict['fake_score'] = fake_d_pred.detach().mean() + + l_d.backward() + self.optimizer_d.step() + + self.log_dict = self.reduce_loss_dict(loss_dict) + + if self.ema_decay > 0: + self.model_ema(decay=self.ema_decay) + + def get_current_visuals(self): + out_dict = OrderedDict() + out_dict['lq'] = self.lq_rgb.detach().cpu() + out_dict['result'] = self.output_rgb.detach().cpu() + if self.opt['logger'].get('save_snapshot_verbose', False): # only for verbose + self.output_lab_chroma = torch.cat([torch.ones_like(self.lq) * 50, self.output_ab], dim=1) + self.output_rgb_chroma = tensor_lab2rgb(self.output_lab_chroma) + out_dict['result_chroma'] = self.output_rgb_chroma.detach().cpu() + + if hasattr(self, 'gt'): + out_dict['gt'] = self.gt_rgb.detach().cpu() + if self.opt['logger'].get('save_snapshot_verbose', False): # only for verbose + self.gt_lab_chroma = torch.cat([torch.ones_like(self.lq) * 50, self.gt], dim=1) + self.gt_rgb_chroma = tensor_lab2rgb(self.gt_lab_chroma) + out_dict['gt_chroma'] = self.gt_rgb_chroma.detach().cpu() + return out_dict + + def test(self): + if hasattr(self, 'net_g_ema'): + self.net_g_ema.eval() + with torch.no_grad(): + self.output_ab = self.net_g_ema(self.lq_rgb) + self.output_lab = torch.cat([self.lq, self.output_ab], dim=1) + self.output_rgb = tensor_lab2rgb(self.output_lab) + else: + self.net_g.eval() + with torch.no_grad(): + self.output_ab = self.net_g(self.lq_rgb) + self.output_lab = torch.cat([self.lq, self.output_ab], dim=1) + self.output_rgb = tensor_lab2rgb(self.output_lab) + self.net_g.train() + + def dist_validation(self, dataloader, current_iter, tb_logger, save_img): + if self.opt['rank'] == 0: + self.nondist_validation(dataloader, current_iter, tb_logger, save_img) + + def nondist_validation(self, dataloader, current_iter, tb_logger, save_img): + dataset_name = dataloader.dataset.opt['name'] + with_metrics = self.opt['val'].get('metrics') is not None + use_pbar = self.opt['val'].get('pbar', False) + + if with_metrics and not hasattr(self, 'metric_results'): # only execute in the first run + self.metric_results = {metric: 0 for metric in self.opt['val']['metrics'].keys()} + # initialize the best metric results for each dataset_name (supporting multiple validation datasets) + if with_metrics: + self._initialize_best_metric_results(dataset_name) + # zero self.metric_results + if with_metrics: + self.metric_results = {metric: 0 for metric in self.metric_results} + + metric_data = dict() + if use_pbar: + pbar = tqdm(total=len(dataloader), unit='image') + + if self.opt['val']['metrics'].get('fid') is not None: + fake_acts_set, acts_set = [], [] + + for idx, val_data in enumerate(dataloader): + # if idx == 100: + # break + img_name = osp.splitext(osp.basename(val_data['lq_path'][0]))[0] + if hasattr(self, 'gt'): + del self.gt + self.feed_data(val_data) + self.test() + + visuals = self.get_current_visuals() + sr_img = tensor2img([visuals['result']]) + metric_data['img'] = sr_img + if 'gt' in visuals: + gt_img = tensor2img([visuals['gt']]) + metric_data['img2'] = gt_img + + torch.cuda.empty_cache() + + if save_img: + if self.opt['is_train']: + save_dir = osp.join(self.opt['path']['visualization'], img_name) + for key in visuals: + save_path = os.path.join(save_dir, '{}_{}.png'.format(current_iter, key)) + img = tensor2img(visuals[key]) + imwrite(img, save_path) + else: + if self.opt['val']['suffix']: + save_img_path = osp.join(self.opt['path']['visualization'], dataset_name, + f'{img_name}_{self.opt["val"]["suffix"]}.png') + else: + save_img_path = osp.join(self.opt['path']['visualization'], dataset_name, + f'{img_name}_{self.opt["name"]}.png') + imwrite(sr_img, save_img_path) + + if with_metrics: + # calculate metrics + for name, opt_ in self.opt['val']['metrics'].items(): + if name == 'fid': + pred, gt = visuals['result'].cuda(), visuals['gt'].cuda() + fake_act = get_activations(pred, self.inception_model_fid, 1) + fake_acts_set.append(fake_act) + if self.real_mu is None: + real_act = get_activations(gt, self.inception_model_fid, 1) + acts_set.append(real_act) + else: + self.metric_results[name] += calculate_metric(metric_data, opt_) + if use_pbar: + pbar.update(1) + pbar.set_description(f'Test {img_name}') + if use_pbar: + pbar.close() + + if with_metrics: + if self.opt['val']['metrics'].get('fid') is not None: + if self.real_mu is None: + acts_set = np.concatenate(acts_set, 0) + self.real_mu, self.real_sigma = calculate_activation_statistics(acts_set) + fake_acts_set = np.concatenate(fake_acts_set, 0) + fake_mu, fake_sigma = calculate_activation_statistics(fake_acts_set) + + fid_score = calculate_frechet_distance(self.real_mu, self.real_sigma, fake_mu, fake_sigma) + self.metric_results['fid'] = fid_score + + for metric in self.metric_results.keys(): + if metric != 'fid': + self.metric_results[metric] /= (idx + 1) + # update the best metric result + self._update_best_metric_result(dataset_name, metric, self.metric_results[metric], current_iter) + + self._log_validation_metric_values(current_iter, dataset_name, tb_logger) + + def _log_validation_metric_values(self, current_iter, dataset_name, tb_logger): + log_str = f'Validation {dataset_name}\n' + for metric, value in self.metric_results.items(): + log_str += f'\t # {metric}: {value:.4f}' + if hasattr(self, 'best_metric_results'): + log_str += (f'\tBest: {self.best_metric_results[dataset_name][metric]["val"]:.4f} @ ' + f'{self.best_metric_results[dataset_name][metric]["iter"]} iter') + log_str += '\n' + + logger = get_root_logger() + logger.info(log_str) + if tb_logger: + for metric, value in self.metric_results.items(): + tb_logger.add_scalar(f'metrics/{dataset_name}/{metric}', value, current_iter) + + def _prepare_inception_model_fid(self, path='pretrain/inception_v3_google-1a9a5a14.pth'): + incep_state_dict = torch.load(path, map_location='cpu') + block_idx = INCEPTION_V3_FID.BLOCK_INDEX_BY_DIM[2048] + self.inception_model_fid = INCEPTION_V3_FID(incep_state_dict, [block_idx]) + self.inception_model_fid.cuda() + self.inception_model_fid.eval() + + @master_only + def save_training_images(self, current_iter): + visuals = self.get_current_visuals() + save_dir = osp.join(self.opt['root_path'], 'experiments', self.opt['name'], 'training_images_snapshot') + os.makedirs(save_dir, exist_ok=True) + + for key in visuals: + save_path = os.path.join(save_dir, '{}_{}.png'.format(current_iter, key)) + img = tensor2img(visuals[key]) + imwrite(img, save_path) + + def save(self, epoch, current_iter): + if hasattr(self, 'net_g_ema'): + self.save_network([self.net_g, self.net_g_ema], 'net_g', current_iter, param_key=['params', 'params_ema']) + else: + self.save_network(self.net_g, 'net_g', current_iter) + self.save_network(self.net_d, 'net_d', current_iter) + self.save_training_state(epoch, current_iter) diff --git a/basicsr/models/lr_scheduler.py b/basicsr/models/lr_scheduler.py new file mode 100644 index 0000000000000000000000000000000000000000..11e1c6c7a74f5233accda52370f92681d3d3cecf --- /dev/null +++ b/basicsr/models/lr_scheduler.py @@ -0,0 +1,96 @@ +import math +from collections import Counter +from torch.optim.lr_scheduler import _LRScheduler + + +class MultiStepRestartLR(_LRScheduler): + """ MultiStep with restarts learning rate scheme. + + Args: + optimizer (torch.nn.optimizer): Torch optimizer. + milestones (list): Iterations that will decrease learning rate. + gamma (float): Decrease ratio. Default: 0.1. + restarts (list): Restart iterations. Default: [0]. + restart_weights (list): Restart weights at each restart iteration. + Default: [1]. + last_epoch (int): Used in _LRScheduler. Default: -1. + """ + + def __init__(self, optimizer, milestones, gamma=0.1, restarts=(0, ), restart_weights=(1, ), last_epoch=-1): + self.milestones = Counter(milestones) + self.gamma = gamma + self.restarts = restarts + self.restart_weights = restart_weights + assert len(self.restarts) == len(self.restart_weights), 'restarts and their weights do not match.' + super(MultiStepRestartLR, self).__init__(optimizer, last_epoch) + + def get_lr(self): + if self.last_epoch in self.restarts: + weight = self.restart_weights[self.restarts.index(self.last_epoch)] + return [group['initial_lr'] * weight for group in self.optimizer.param_groups] + if self.last_epoch not in self.milestones: + return [group['lr'] for group in self.optimizer.param_groups] + return [group['lr'] * self.gamma**self.milestones[self.last_epoch] for group in self.optimizer.param_groups] + + +def get_position_from_periods(iteration, cumulative_period): + """Get the position from a period list. + + It will return the index of the right-closest number in the period list. + For example, the cumulative_period = [100, 200, 300, 400], + if iteration == 50, return 0; + if iteration == 210, return 2; + if iteration == 300, return 2. + + Args: + iteration (int): Current iteration. + cumulative_period (list[int]): Cumulative period list. + + Returns: + int: The position of the right-closest number in the period list. + """ + for i, period in enumerate(cumulative_period): + if iteration <= period: + return i + + +class CosineAnnealingRestartLR(_LRScheduler): + """ Cosine annealing with restarts learning rate scheme. + + An example of config: + periods = [10, 10, 10, 10] + restart_weights = [1, 0.5, 0.5, 0.5] + eta_min=1e-7 + + It has four cycles, each has 10 iterations. At 10th, 20th, 30th, the + scheduler will restart with the weights in restart_weights. + + Args: + optimizer (torch.nn.optimizer): Torch optimizer. + periods (list): Period for each cosine anneling cycle. + restart_weights (list): Restart weights at each restart iteration. + Default: [1]. + eta_min (float): The minimum lr. Default: 0. + last_epoch (int): Used in _LRScheduler. Default: -1. + """ + + def __init__(self, optimizer, periods, restart_weights=(1, ), eta_min=0, last_epoch=-1): + self.periods = periods + self.restart_weights = restart_weights + self.eta_min = eta_min + assert (len(self.periods) == len( + self.restart_weights)), 'periods and restart_weights should have the same length.' + self.cumulative_period = [sum(self.periods[0:i + 1]) for i in range(0, len(self.periods))] + super(CosineAnnealingRestartLR, self).__init__(optimizer, last_epoch) + + def get_lr(self): + idx = get_position_from_periods(self.last_epoch, self.cumulative_period) + current_weight = self.restart_weights[idx] + nearest_restart = 0 if idx == 0 else self.cumulative_period[idx - 1] + current_period = self.periods[idx] + + return [ + self.eta_min + current_weight * 0.5 * (base_lr - self.eta_min) * + (1 + math.cos(math.pi * ((self.last_epoch - nearest_restart) / current_period))) + for base_lr in self.base_lrs + ] diff --git a/basicsr/train.py b/basicsr/train.py new file mode 100644 index 0000000000000000000000000000000000000000..49d89aebd197c6955f16d3837a2d60472a7f3270 --- /dev/null +++ b/basicsr/train.py @@ -0,0 +1,224 @@ +import datetime +import logging +import math +import time +import torch +import warnings + +warnings.filterwarnings("ignore") + +from os import path as osp + +from basicsr.data import build_dataloader, build_dataset +from basicsr.data.data_sampler import EnlargedSampler +from basicsr.data.prefetch_dataloader import CPUPrefetcher, CUDAPrefetcher +from basicsr.models import build_model +from basicsr.utils import (AvgTimer, MessageLogger, check_resume, get_env_info, get_root_logger, get_time_str, + init_tb_logger, init_wandb_logger, make_exp_dirs, mkdir_and_rename, scandir) +from basicsr.utils.options import copy_opt_file, dict2str, parse_options + + +def init_tb_loggers(opt): + # initialize wandb logger before tensorboard logger to allow proper sync + if (opt['logger'].get('wandb') is not None) and (opt['logger']['wandb'].get('project') + is not None) and ('debug' not in opt['name']): + assert opt['logger'].get('use_tb_logger') is True, ('should turn on tensorboard when using wandb') + init_wandb_logger(opt) + tb_logger = None + if opt['logger'].get('use_tb_logger') and 'debug' not in opt['name']: + tb_logger = init_tb_logger(log_dir=osp.join(opt['root_path'], 'tb_logger', opt['name'])) + return tb_logger + + +def create_train_val_dataloader(opt, logger): + # create train and val dataloaders + train_loader, val_loaders = None, [] + for phase, dataset_opt in opt['datasets'].items(): + if phase == 'train': + dataset_enlarge_ratio = dataset_opt.get('dataset_enlarge_ratio', 1) + train_set = build_dataset(dataset_opt) + train_sampler = EnlargedSampler(train_set, opt['world_size'], opt['rank'], dataset_enlarge_ratio) + train_loader = build_dataloader( + train_set, + dataset_opt, + num_gpu=opt['num_gpu'], + dist=opt['dist'], + sampler=train_sampler, + seed=opt['manual_seed']) + + num_iter_per_epoch = math.ceil( + len(train_set) * dataset_enlarge_ratio / (dataset_opt['batch_size_per_gpu'] * opt['world_size'])) + total_iters = int(opt['train']['total_iter']) + total_epochs = math.ceil(total_iters / (num_iter_per_epoch)) + logger.info('Training statistics:' + f'\n\tNumber of train images: {len(train_set)}' + f'\n\tDataset enlarge ratio: {dataset_enlarge_ratio}' + f'\n\tBatch size per gpu: {dataset_opt["batch_size_per_gpu"]}' + f'\n\tWorld size (gpu number): {opt["world_size"]}' + f'\n\tRequire iter number per epoch: {num_iter_per_epoch}' + f'\n\tTotal epochs: {total_epochs}; iters: {total_iters}.') + elif phase.split('_')[0] == 'val': + val_set = build_dataset(dataset_opt) + val_loader = build_dataloader( + val_set, dataset_opt, num_gpu=opt['num_gpu'], dist=opt['dist'], sampler=None, seed=opt['manual_seed']) + logger.info(f'Number of val images/folders in {dataset_opt["name"]}: {len(val_set)}') + val_loaders.append(val_loader) + else: + raise ValueError(f'Dataset phase {phase} is not recognized.') + + return train_loader, train_sampler, val_loaders, total_epochs, total_iters + + +def load_resume_state(opt): + resume_state_path = None + if opt['auto_resume']: + state_path = osp.join(opt['root_path'], 'experiments', opt['name'], 'training_states') + if osp.isdir(state_path): + states = list(scandir(state_path, suffix='state', recursive=False, full_path=False)) + if len(states) != 0: + states = [float(v.split('.state')[0]) for v in states] + resume_state_path = osp.join(state_path, f'{max(states):.0f}.state') + opt['path']['resume_state'] = resume_state_path + else: + if opt['path'].get('resume_state'): + resume_state_path = opt['path']['resume_state'] + + if resume_state_path is None: + resume_state = None + else: + device_id = torch.cuda.current_device() + resume_state = torch.load(resume_state_path, map_location=lambda storage, loc: storage.cuda(device_id)) + check_resume(opt, resume_state['iter']) + return resume_state + + +def train_pipeline(root_path): + # parse options, set distributed setting, set ramdom seed + opt, args = parse_options(root_path, is_train=True) + opt['root_path'] = root_path + + torch.backends.cudnn.benchmark = True + # torch.backends.cudnn.deterministic = True + + # load resume states if necessary + resume_state = load_resume_state(opt) + # mkdir for experiments and logger + if resume_state is None: + make_exp_dirs(opt) + if opt['logger'].get('use_tb_logger') and 'debug' not in opt['name'] and opt['rank'] == 0: + mkdir_and_rename(osp.join(opt['root_path'], 'tb_logger', opt['name'])) + + # copy the yml file to the experiment root + copy_opt_file(args.opt, opt['path']['experiments_root']) + + # WARNING: should not use get_root_logger in the above codes, including the called functions + # Otherwise the logger will not be properly initialized + log_file = osp.join(opt['path']['log'], f"train_{opt['name']}_{get_time_str()}.log") + logger = get_root_logger(logger_name='basicsr', log_level=logging.INFO, log_file=log_file) + logger.info(get_env_info()) + logger.info(dict2str(opt)) + # initialize wandb and tb loggers + tb_logger = init_tb_loggers(opt) + + # create train and validation dataloaders + result = create_train_val_dataloader(opt, logger) + train_loader, train_sampler, val_loaders, total_epochs, total_iters = result + + # create model + model = build_model(opt) + if resume_state: # resume training + model.resume_training(resume_state) # handle optimizers and schedulers + logger.info(f"Resuming training from epoch: {resume_state['epoch']}, " f"iter: {resume_state['iter']}.") + start_epoch = resume_state['epoch'] + current_iter = resume_state['iter'] + else: + start_epoch = 0 + current_iter = 0 + + # create message logger (formatted outputs) + msg_logger = MessageLogger(opt, current_iter, tb_logger) + + # dataloader prefetcher + prefetch_mode = opt['datasets']['train'].get('prefetch_mode') + if prefetch_mode is None or prefetch_mode == 'cpu': + prefetcher = CPUPrefetcher(train_loader) + elif prefetch_mode == 'cuda': + prefetcher = CUDAPrefetcher(train_loader, opt) + logger.info(f'Use {prefetch_mode} prefetch dataloader') + if opt['datasets']['train'].get('pin_memory') is not True: + raise ValueError('Please set pin_memory=True for CUDAPrefetcher.') + else: + raise ValueError(f'Wrong prefetch_mode {prefetch_mode}.' "Supported ones are: None, 'cuda', 'cpu'.") + + # training + logger.info(f'Start training from epoch: {start_epoch}, iter: {current_iter}') + data_timer, iter_timer = AvgTimer(), AvgTimer() + start_time = time.time() + + for epoch in range(start_epoch, total_epochs + 1): + train_sampler.set_epoch(epoch) + prefetcher.reset() + train_data = prefetcher.next() + + while train_data is not None: + data_timer.record() + + current_iter += 1 + if current_iter > total_iters: + break + # update learning rate + model.update_learning_rate(current_iter, warmup_iter=opt['train'].get('warmup_iter', -1)) + # training + model.feed_data(train_data) + model.optimize_parameters(current_iter) + iter_timer.record() + if current_iter == 1: + # reset start time in msg_logger for more accurate eta_time + # not work in resume mode + msg_logger.reset_start_time() + # log + if current_iter % opt['logger']['print_freq'] == 0: + log_vars = {'epoch': epoch, 'iter': current_iter} + log_vars.update({'lrs': model.get_current_learning_rate()}) + log_vars.update({'time': iter_timer.get_avg_time(), 'data_time': data_timer.get_avg_time()}) + log_vars.update(model.get_current_log()) + msg_logger(log_vars) + + # save training images snapshot save_snapshot_freq + if opt['logger'][ + 'save_snapshot_freq'] is not None and current_iter % opt['logger']['save_snapshot_freq'] == 0: + model.save_training_images(current_iter) + + # save models and training states + if current_iter % opt['logger']['save_checkpoint_freq'] == 0: + logger.info('Saving models and training states.') + model.save(epoch, current_iter) + + # validation + if opt.get('val') is not None and (current_iter % opt['val']['val_freq'] == 0): + if len(val_loaders) > 1: + logger.warning('Multiple validation datasets are *only* supported by SRModel.') + for val_loader in val_loaders: + model.validation(val_loader, current_iter, tb_logger, opt['val']['save_img']) + + data_timer.start() + iter_timer.start() + train_data = prefetcher.next() + # end of iter + + # end of epoch + + consumed_time = str(datetime.timedelta(seconds=int(time.time() - start_time))) + logger.info(f'End of training. Time consumed: {consumed_time}') + logger.info('Save the latest model.') + model.save(epoch=-1, current_iter=-1) # -1 stands for the latest + if opt.get('val') is not None: + for val_loader in val_loaders: + model.validation(val_loader, current_iter, tb_logger, opt['val']['save_img']) + if tb_logger: + tb_logger.close() + + +if __name__ == '__main__': + root_path = osp.abspath(osp.join(__file__, osp.pardir, osp.pardir)) + train_pipeline(root_path) diff --git a/basicsr/utils/__init__.py b/basicsr/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..902b293cdf189e8324731d438249fd3089d2b0fa --- /dev/null +++ b/basicsr/utils/__init__.py @@ -0,0 +1,37 @@ +from .diffjpeg import DiffJPEG +from .file_client import FileClient +from .img_process_util import USMSharp, usm_sharp +from .img_util import crop_border, imfrombytes, img2tensor, imwrite, tensor2img +from .logger import AvgTimer, MessageLogger, get_env_info, get_root_logger, init_tb_logger, init_wandb_logger +from .misc import check_resume, get_time_str, make_exp_dirs, mkdir_and_rename, scandir, set_random_seed, sizeof_fmt + +__all__ = [ + # file_client.py + 'FileClient', + # img_util.py + 'img2tensor', + 'tensor2img', + 'imfrombytes', + 'imwrite', + 'crop_border', + # logger.py + 'MessageLogger', + 'AvgTimer', + 'init_tb_logger', + 'init_wandb_logger', + 'get_root_logger', + 'get_env_info', + # misc.py + 'set_random_seed', + 'get_time_str', + 'mkdir_and_rename', + 'make_exp_dirs', + 'scandir', + 'check_resume', + 'sizeof_fmt', + # diffjpeg + 'DiffJPEG', + # img_process_util + 'USMSharp', + 'usm_sharp' +] diff --git a/basicsr/utils/color_enhance.py b/basicsr/utils/color_enhance.py new file mode 100644 index 0000000000000000000000000000000000000000..3121f47c8588b5aa98c628f6934bc0f06013826b --- /dev/null +++ b/basicsr/utils/color_enhance.py @@ -0,0 +1,9 @@ +from torchvision.transforms import ToTensor, Grayscale + + +def color_enhacne_blend(x, factor=1.2): + x_g = Grayscale(3)(x) + out = x_g * (1.0 - factor) + x * factor + out[out < 0] = 0 + out[out > 1] = 1 + return out \ No newline at end of file diff --git a/basicsr/utils/diffjpeg.py b/basicsr/utils/diffjpeg.py new file mode 100644 index 0000000000000000000000000000000000000000..65f96b44f9e7f3f8a589668f0003adf328cc5742 --- /dev/null +++ b/basicsr/utils/diffjpeg.py @@ -0,0 +1,515 @@ +""" +Modified from https://github.com/mlomnitz/DiffJPEG + +For images not divisible by 8 +https://dsp.stackexchange.com/questions/35339/jpeg-dct-padding/35343#35343 +""" +import itertools +import numpy as np +import torch +import torch.nn as nn +from torch.nn import functional as F + +# ------------------------ utils ------------------------# +y_table = np.array( + [[16, 11, 10, 16, 24, 40, 51, 61], [12, 12, 14, 19, 26, 58, 60, 55], [14, 13, 16, 24, 40, 57, 69, 56], + [14, 17, 22, 29, 51, 87, 80, 62], [18, 22, 37, 56, 68, 109, 103, 77], [24, 35, 55, 64, 81, 104, 113, 92], + [49, 64, 78, 87, 103, 121, 120, 101], [72, 92, 95, 98, 112, 100, 103, 99]], + dtype=np.float32).T +y_table = nn.Parameter(torch.from_numpy(y_table)) +c_table = np.empty((8, 8), dtype=np.float32) +c_table.fill(99) +c_table[:4, :4] = np.array([[17, 18, 24, 47], [18, 21, 26, 66], [24, 26, 56, 99], [47, 66, 99, 99]]).T +c_table = nn.Parameter(torch.from_numpy(c_table)) + + +def diff_round(x): + """ Differentiable rounding function + """ + return torch.round(x) + (x - torch.round(x))**3 + + +def quality_to_factor(quality): + """ Calculate factor corresponding to quality + + Args: + quality(float): Quality for jpeg compression. + + Returns: + float: Compression factor. + """ + if quality < 50: + quality = 5000. / quality + else: + quality = 200. - quality * 2 + return quality / 100. + + +# ------------------------ compression ------------------------# +class RGB2YCbCrJpeg(nn.Module): + """ Converts RGB image to YCbCr + """ + + def __init__(self): + super(RGB2YCbCrJpeg, self).__init__() + matrix = np.array([[0.299, 0.587, 0.114], [-0.168736, -0.331264, 0.5], [0.5, -0.418688, -0.081312]], + dtype=np.float32).T + self.shift = nn.Parameter(torch.tensor([0., 128., 128.])) + self.matrix = nn.Parameter(torch.from_numpy(matrix)) + + def forward(self, image): + """ + Args: + image(Tensor): batch x 3 x height x width + + Returns: + Tensor: batch x height x width x 3 + """ + image = image.permute(0, 2, 3, 1) + result = torch.tensordot(image, self.matrix, dims=1) + self.shift + return result.view(image.shape) + + +class ChromaSubsampling(nn.Module): + """ Chroma subsampling on CbCr channels + """ + + def __init__(self): + super(ChromaSubsampling, self).__init__() + + def forward(self, image): + """ + Args: + image(tensor): batch x height x width x 3 + + Returns: + y(tensor): batch x height x width + cb(tensor): batch x height/2 x width/2 + cr(tensor): batch x height/2 x width/2 + """ + image_2 = image.permute(0, 3, 1, 2).clone() + cb = F.avg_pool2d(image_2[:, 1, :, :].unsqueeze(1), kernel_size=2, stride=(2, 2), count_include_pad=False) + cr = F.avg_pool2d(image_2[:, 2, :, :].unsqueeze(1), kernel_size=2, stride=(2, 2), count_include_pad=False) + cb = cb.permute(0, 2, 3, 1) + cr = cr.permute(0, 2, 3, 1) + return image[:, :, :, 0], cb.squeeze(3), cr.squeeze(3) + + +class BlockSplitting(nn.Module): + """ Splitting image into patches + """ + + def __init__(self): + super(BlockSplitting, self).__init__() + self.k = 8 + + def forward(self, image): + """ + Args: + image(tensor): batch x height x width + + Returns: + Tensor: batch x h*w/64 x h x w + """ + height, _ = image.shape[1:3] + batch_size = image.shape[0] + image_reshaped = image.view(batch_size, height // self.k, self.k, -1, self.k) + image_transposed = image_reshaped.permute(0, 1, 3, 2, 4) + return image_transposed.contiguous().view(batch_size, -1, self.k, self.k) + + +class DCT8x8(nn.Module): + """ Discrete Cosine Transformation + """ + + def __init__(self): + super(DCT8x8, self).__init__() + tensor = np.zeros((8, 8, 8, 8), dtype=np.float32) + for x, y, u, v in itertools.product(range(8), repeat=4): + tensor[x, y, u, v] = np.cos((2 * x + 1) * u * np.pi / 16) * np.cos((2 * y + 1) * v * np.pi / 16) + alpha = np.array([1. / np.sqrt(2)] + [1] * 7) + self.tensor = nn.Parameter(torch.from_numpy(tensor).float()) + self.scale = nn.Parameter(torch.from_numpy(np.outer(alpha, alpha) * 0.25).float()) + + def forward(self, image): + """ + Args: + image(tensor): batch x height x width + + Returns: + Tensor: batch x height x width + """ + image = image - 128 + result = self.scale * torch.tensordot(image, self.tensor, dims=2) + result.view(image.shape) + return result + + +class YQuantize(nn.Module): + """ JPEG Quantization for Y channel + + Args: + rounding(function): rounding function to use + """ + + def __init__(self, rounding): + super(YQuantize, self).__init__() + self.rounding = rounding + self.y_table = y_table + + def forward(self, image, factor=1): + """ + Args: + image(tensor): batch x height x width + + Returns: + Tensor: batch x height x width + """ + if isinstance(factor, (int, float)): + image = image.float() / (self.y_table * factor) + else: + b = factor.size(0) + table = self.y_table.expand(b, 1, 8, 8) * factor.view(b, 1, 1, 1) + image = image.float() / table + image = self.rounding(image) + return image + + +class CQuantize(nn.Module): + """ JPEG Quantization for CbCr channels + + Args: + rounding(function): rounding function to use + """ + + def __init__(self, rounding): + super(CQuantize, self).__init__() + self.rounding = rounding + self.c_table = c_table + + def forward(self, image, factor=1): + """ + Args: + image(tensor): batch x height x width + + Returns: + Tensor: batch x height x width + """ + if isinstance(factor, (int, float)): + image = image.float() / (self.c_table * factor) + else: + b = factor.size(0) + table = self.c_table.expand(b, 1, 8, 8) * factor.view(b, 1, 1, 1) + image = image.float() / table + image = self.rounding(image) + return image + + +class CompressJpeg(nn.Module): + """Full JPEG compression algorithm + + Args: + rounding(function): rounding function to use + """ + + def __init__(self, rounding=torch.round): + super(CompressJpeg, self).__init__() + self.l1 = nn.Sequential(RGB2YCbCrJpeg(), ChromaSubsampling()) + self.l2 = nn.Sequential(BlockSplitting(), DCT8x8()) + self.c_quantize = CQuantize(rounding=rounding) + self.y_quantize = YQuantize(rounding=rounding) + + def forward(self, image, factor=1): + """ + Args: + image(tensor): batch x 3 x height x width + + Returns: + dict(tensor): Compressed tensor with batch x h*w/64 x 8 x 8. + """ + y, cb, cr = self.l1(image * 255) + components = {'y': y, 'cb': cb, 'cr': cr} + for k in components.keys(): + comp = self.l2(components[k]) + if k in ('cb', 'cr'): + comp = self.c_quantize(comp, factor=factor) + else: + comp = self.y_quantize(comp, factor=factor) + + components[k] = comp + + return components['y'], components['cb'], components['cr'] + + +# ------------------------ decompression ------------------------# + + +class YDequantize(nn.Module): + """Dequantize Y channel + """ + + def __init__(self): + super(YDequantize, self).__init__() + self.y_table = y_table + + def forward(self, image, factor=1): + """ + Args: + image(tensor): batch x height x width + + Returns: + Tensor: batch x height x width + """ + if isinstance(factor, (int, float)): + out = image * (self.y_table * factor) + else: + b = factor.size(0) + table = self.y_table.expand(b, 1, 8, 8) * factor.view(b, 1, 1, 1) + out = image * table + return out + + +class CDequantize(nn.Module): + """Dequantize CbCr channel + """ + + def __init__(self): + super(CDequantize, self).__init__() + self.c_table = c_table + + def forward(self, image, factor=1): + """ + Args: + image(tensor): batch x height x width + + Returns: + Tensor: batch x height x width + """ + if isinstance(factor, (int, float)): + out = image * (self.c_table * factor) + else: + b = factor.size(0) + table = self.c_table.expand(b, 1, 8, 8) * factor.view(b, 1, 1, 1) + out = image * table + return out + + +class iDCT8x8(nn.Module): + """Inverse discrete Cosine Transformation + """ + + def __init__(self): + super(iDCT8x8, self).__init__() + alpha = np.array([1. / np.sqrt(2)] + [1] * 7) + self.alpha = nn.Parameter(torch.from_numpy(np.outer(alpha, alpha)).float()) + tensor = np.zeros((8, 8, 8, 8), dtype=np.float32) + for x, y, u, v in itertools.product(range(8), repeat=4): + tensor[x, y, u, v] = np.cos((2 * u + 1) * x * np.pi / 16) * np.cos((2 * v + 1) * y * np.pi / 16) + self.tensor = nn.Parameter(torch.from_numpy(tensor).float()) + + def forward(self, image): + """ + Args: + image(tensor): batch x height x width + + Returns: + Tensor: batch x height x width + """ + image = image * self.alpha + result = 0.25 * torch.tensordot(image, self.tensor, dims=2) + 128 + result.view(image.shape) + return result + + +class BlockMerging(nn.Module): + """Merge patches into image + """ + + def __init__(self): + super(BlockMerging, self).__init__() + + def forward(self, patches, height, width): + """ + Args: + patches(tensor) batch x height*width/64, height x width + height(int) + width(int) + + Returns: + Tensor: batch x height x width + """ + k = 8 + batch_size = patches.shape[0] + image_reshaped = patches.view(batch_size, height // k, width // k, k, k) + image_transposed = image_reshaped.permute(0, 1, 3, 2, 4) + return image_transposed.contiguous().view(batch_size, height, width) + + +class ChromaUpsampling(nn.Module): + """Upsample chroma layers + """ + + def __init__(self): + super(ChromaUpsampling, self).__init__() + + def forward(self, y, cb, cr): + """ + Args: + y(tensor): y channel image + cb(tensor): cb channel + cr(tensor): cr channel + + Returns: + Tensor: batch x height x width x 3 + """ + + def repeat(x, k=2): + height, width = x.shape[1:3] + x = x.unsqueeze(-1) + x = x.repeat(1, 1, k, k) + x = x.view(-1, height * k, width * k) + return x + + cb = repeat(cb) + cr = repeat(cr) + return torch.cat([y.unsqueeze(3), cb.unsqueeze(3), cr.unsqueeze(3)], dim=3) + + +class YCbCr2RGBJpeg(nn.Module): + """Converts YCbCr image to RGB JPEG + """ + + def __init__(self): + super(YCbCr2RGBJpeg, self).__init__() + + matrix = np.array([[1., 0., 1.402], [1, -0.344136, -0.714136], [1, 1.772, 0]], dtype=np.float32).T + self.shift = nn.Parameter(torch.tensor([0, -128., -128.])) + self.matrix = nn.Parameter(torch.from_numpy(matrix)) + + def forward(self, image): + """ + Args: + image(tensor): batch x height x width x 3 + + Returns: + Tensor: batch x 3 x height x width + """ + result = torch.tensordot(image + self.shift, self.matrix, dims=1) + return result.view(image.shape).permute(0, 3, 1, 2) + + +class DeCompressJpeg(nn.Module): + """Full JPEG decompression algorithm + + Args: + rounding(function): rounding function to use + """ + + def __init__(self, rounding=torch.round): + super(DeCompressJpeg, self).__init__() + self.c_dequantize = CDequantize() + self.y_dequantize = YDequantize() + self.idct = iDCT8x8() + self.merging = BlockMerging() + self.chroma = ChromaUpsampling() + self.colors = YCbCr2RGBJpeg() + + def forward(self, y, cb, cr, imgh, imgw, factor=1): + """ + Args: + compressed(dict(tensor)): batch x h*w/64 x 8 x 8 + imgh(int) + imgw(int) + factor(float) + + Returns: + Tensor: batch x 3 x height x width + """ + components = {'y': y, 'cb': cb, 'cr': cr} + for k in components.keys(): + if k in ('cb', 'cr'): + comp = self.c_dequantize(components[k], factor=factor) + height, width = int(imgh / 2), int(imgw / 2) + else: + comp = self.y_dequantize(components[k], factor=factor) + height, width = imgh, imgw + comp = self.idct(comp) + components[k] = self.merging(comp, height, width) + # + image = self.chroma(components['y'], components['cb'], components['cr']) + image = self.colors(image) + + image = torch.min(255 * torch.ones_like(image), torch.max(torch.zeros_like(image), image)) + return image / 255 + + +# ------------------------ main DiffJPEG ------------------------ # + + +class DiffJPEG(nn.Module): + """This JPEG algorithm result is slightly different from cv2. + DiffJPEG supports batch processing. + + Args: + differentiable(bool): If True, uses custom differentiable rounding function, if False, uses standard torch.round + """ + + def __init__(self, differentiable=True): + super(DiffJPEG, self).__init__() + if differentiable: + rounding = diff_round + else: + rounding = torch.round + + self.compress = CompressJpeg(rounding=rounding) + self.decompress = DeCompressJpeg(rounding=rounding) + + def forward(self, x, quality): + """ + Args: + x (Tensor): Input image, bchw, rgb, [0, 1] + quality(float): Quality factor for jpeg compression scheme. + """ + factor = quality + if isinstance(factor, (int, float)): + factor = quality_to_factor(factor) + else: + for i in range(factor.size(0)): + factor[i] = quality_to_factor(factor[i]) + h, w = x.size()[-2:] + h_pad, w_pad = 0, 0 + # why should use 16 + if h % 16 != 0: + h_pad = 16 - h % 16 + if w % 16 != 0: + w_pad = 16 - w % 16 + x = F.pad(x, (0, w_pad, 0, h_pad), mode='constant', value=0) + + y, cb, cr = self.compress(x, factor=factor) + recovered = self.decompress(y, cb, cr, (h + h_pad), (w + w_pad), factor=factor) + recovered = recovered[:, :, 0:h, 0:w] + return recovered + + +if __name__ == '__main__': + import cv2 + + from basicsr.utils import img2tensor, tensor2img + + img_gt = cv2.imread('test.png') / 255. + + # -------------- cv2 -------------- # + encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 20] + _, encimg = cv2.imencode('.jpg', img_gt * 255., encode_param) + img_lq = np.float32(cv2.imdecode(encimg, 1)) + cv2.imwrite('cv2_JPEG_20.png', img_lq) + + # -------------- DiffJPEG -------------- # + jpeger = DiffJPEG(differentiable=False).cuda() + img_gt = img2tensor(img_gt) + img_gt = torch.stack([img_gt, img_gt]).cuda() + quality = img_gt.new_tensor([20, 40]) + out = jpeger(img_gt, quality=quality) + + cv2.imwrite('pt_JPEG_20.png', tensor2img(out[0])) + cv2.imwrite('pt_JPEG_40.png', tensor2img(out[1])) diff --git a/basicsr/utils/dist_util.py b/basicsr/utils/dist_util.py new file mode 100644 index 0000000000000000000000000000000000000000..0fab887b2cb1ce8533d2e8fdee72ae0c24f68fd0 --- /dev/null +++ b/basicsr/utils/dist_util.py @@ -0,0 +1,82 @@ +# Modified from https://github.com/open-mmlab/mmcv/blob/master/mmcv/runner/dist_utils.py # noqa: E501 +import functools +import os +import subprocess +import torch +import torch.distributed as dist +import torch.multiprocessing as mp + + +def init_dist(launcher, backend='nccl', **kwargs): + if mp.get_start_method(allow_none=True) is None: + mp.set_start_method('spawn') + if launcher == 'pytorch': + _init_dist_pytorch(backend, **kwargs) + elif launcher == 'slurm': + _init_dist_slurm(backend, **kwargs) + else: + raise ValueError(f'Invalid launcher type: {launcher}') + + +def _init_dist_pytorch(backend, **kwargs): + rank = int(os.environ['RANK']) + num_gpus = torch.cuda.device_count() + torch.cuda.set_device(rank % num_gpus) + dist.init_process_group(backend=backend, **kwargs) + + +def _init_dist_slurm(backend, port=None): + """Initialize slurm distributed training environment. + + If argument ``port`` is not specified, then the master port will be system + environment variable ``MASTER_PORT``. If ``MASTER_PORT`` is not in system + environment variable, then a default port ``29500`` will be used. + + Args: + backend (str): Backend of torch.distributed. + port (int, optional): Master port. Defaults to None. + """ + proc_id = int(os.environ['SLURM_PROCID']) + ntasks = int(os.environ['SLURM_NTASKS']) + node_list = os.environ['SLURM_NODELIST'] + num_gpus = torch.cuda.device_count() + torch.cuda.set_device(proc_id % num_gpus) + addr = subprocess.getoutput(f'scontrol show hostname {node_list} | head -n1') + # specify master port + if port is not None: + os.environ['MASTER_PORT'] = str(port) + elif 'MASTER_PORT' in os.environ: + pass # use MASTER_PORT in the environment variable + else: + # 29500 is torch.distributed default port + os.environ['MASTER_PORT'] = '29500' + os.environ['MASTER_ADDR'] = addr + os.environ['WORLD_SIZE'] = str(ntasks) + os.environ['LOCAL_RANK'] = str(proc_id % num_gpus) + os.environ['RANK'] = str(proc_id) + dist.init_process_group(backend=backend) + + +def get_dist_info(): + if dist.is_available(): + initialized = dist.is_initialized() + else: + initialized = False + if initialized: + rank = dist.get_rank() + world_size = dist.get_world_size() + else: + rank = 0 + world_size = 1 + return rank, world_size + + +def master_only(func): + + @functools.wraps(func) + def wrapper(*args, **kwargs): + rank, _ = get_dist_info() + if rank == 0: + return func(*args, **kwargs) + + return wrapper diff --git a/basicsr/utils/download_util.py b/basicsr/utils/download_util.py new file mode 100644 index 0000000000000000000000000000000000000000..6e12898bbb165de7f9bba31d5177e5c0bbcf4404 --- /dev/null +++ b/basicsr/utils/download_util.py @@ -0,0 +1,64 @@ +import math +import requests +from tqdm import tqdm + +from .misc import sizeof_fmt + + +def download_file_from_google_drive(file_id, save_path): + """Download files from google drive. + + Ref: + https://stackoverflow.com/questions/25010369/wget-curl-large-file-from-google-drive # noqa E501 + + Args: + file_id (str): File id. + save_path (str): Save path. + """ + + session = requests.Session() + URL = 'https://docs.google.com/uc?export=download' + params = {'id': file_id} + + response = session.get(URL, params=params, stream=True) + token = get_confirm_token(response) + if token: + params['confirm'] = token + response = session.get(URL, params=params, stream=True) + + # get file size + response_file_size = session.get(URL, params=params, stream=True, headers={'Range': 'bytes=0-2'}) + if 'Content-Range' in response_file_size.headers: + file_size = int(response_file_size.headers['Content-Range'].split('/')[1]) + else: + file_size = None + + save_response_content(response, save_path, file_size) + + +def get_confirm_token(response): + for key, value in response.cookies.items(): + if key.startswith('download_warning'): + return value + return None + + +def save_response_content(response, destination, file_size=None, chunk_size=32768): + if file_size is not None: + pbar = tqdm(total=math.ceil(file_size / chunk_size), unit='chunk') + + readable_file_size = sizeof_fmt(file_size) + else: + pbar = None + + with open(destination, 'wb') as f: + downloaded_size = 0 + for chunk in response.iter_content(chunk_size): + downloaded_size += chunk_size + if pbar is not None: + pbar.update(1) + pbar.set_description(f'Download {sizeof_fmt(downloaded_size)} / {readable_file_size}') + if chunk: # filter out keep-alive new chunks + f.write(chunk) + if pbar is not None: + pbar.close() diff --git a/basicsr/utils/face_util.py b/basicsr/utils/face_util.py new file mode 100644 index 0000000000000000000000000000000000000000..e6f2552ed459e7c15929c30b503347d7d8b9cbdb --- /dev/null +++ b/basicsr/utils/face_util.py @@ -0,0 +1,192 @@ +import cv2 +import numpy as np +import os +import torch +from skimage import transform as trans + +from basicsr.utils import imwrite + +try: + import dlib +except ImportError: + print('Please install dlib before testing face restoration.' 'Reference:　https://github.com/davisking/dlib') + + +class FaceRestorationHelper(object): + """Helper for the face restoration pipeline.""" + + def __init__(self, upscale_factor, face_size=512): + self.upscale_factor = upscale_factor + self.face_size = (face_size, face_size) + + # standard 5 landmarks for FFHQ faces with 1024 x 1024 + self.face_template = np.array([[686.77227723, 488.62376238], [586.77227723, 493.59405941], + [337.91089109, 488.38613861], [437.95049505, 493.51485149], + [513.58415842, 678.5049505]]) + self.face_template = self.face_template / (1024 // face_size) + # for estimation the 2D similarity transformation + self.similarity_trans = trans.SimilarityTransform() + + self.all_landmarks_5 = [] + self.all_landmarks_68 = [] + self.affine_matrices = [] + self.inverse_affine_matrices = [] + self.cropped_faces = [] + self.restored_faces = [] + self.save_png = True + + def init_dlib(self, detection_path, landmark5_path, landmark68_path): + """Initialize the dlib detectors and predictors.""" + self.face_detector = dlib.cnn_face_detection_model_v1(detection_path) + self.shape_predictor_5 = dlib.shape_predictor(landmark5_path) + self.shape_predictor_68 = dlib.shape_predictor(landmark68_path) + + def free_dlib_gpu_memory(self): + del self.face_detector + del self.shape_predictor_5 + del self.shape_predictor_68 + + def read_input_image(self, img_path): + # self.input_img is Numpy array, (h, w, c) with RGB order + self.input_img = dlib.load_rgb_image(img_path) + + def detect_faces(self, img_path, upsample_num_times=1, only_keep_largest=False): + """ + Args: + img_path (str): Image path. + upsample_num_times (int): Upsamples the image before running the + face detector + + Returns: + int: Number of detected faces. + """ + self.read_input_image(img_path) + det_faces = self.face_detector(self.input_img, upsample_num_times) + if len(det_faces) == 0: + print('No face detected. Try to increase upsample_num_times.') + else: + if only_keep_largest: + print('Detect several faces and only keep the largest.') + face_areas = [] + for i in range(len(det_faces)): + face_area = (det_faces[i].rect.right() - det_faces[i].rect.left()) * ( + det_faces[i].rect.bottom() - det_faces[i].rect.top()) + face_areas.append(face_area) + largest_idx = face_areas.index(max(face_areas)) + self.det_faces = [det_faces[largest_idx]] + else: + self.det_faces = det_faces + return len(self.det_faces) + + def get_face_landmarks_5(self): + for face in self.det_faces: + shape = self.shape_predictor_5(self.input_img, face.rect) + landmark = np.array([[part.x, part.y] for part in shape.parts()]) + self.all_landmarks_5.append(landmark) + return len(self.all_landmarks_5) + + def get_face_landmarks_68(self): + """Get 68 densemarks for cropped images. + + Should only have one face at most in the cropped image. + """ + num_detected_face = 0 + for idx, face in enumerate(self.cropped_faces): + # face detection + det_face = self.face_detector(face, 1) # TODO: can we remove it? + if len(det_face) == 0: + print(f'Cannot find faces in cropped image with index {idx}.') + self.all_landmarks_68.append(None) + else: + if len(det_face) > 1: + print('Detect several faces in the cropped face. Use the ' + ' largest one. Note that it will also cause overlap ' + 'during paste_faces_to_input_image.') + face_areas = [] + for i in range(len(det_face)): + face_area = (det_face[i].rect.right() - det_face[i].rect.left()) * ( + det_face[i].rect.bottom() - det_face[i].rect.top()) + face_areas.append(face_area) + largest_idx = face_areas.index(max(face_areas)) + face_rect = det_face[largest_idx].rect + else: + face_rect = det_face[0].rect + shape = self.shape_predictor_68(face, face_rect) + landmark = np.array([[part.x, part.y] for part in shape.parts()]) + self.all_landmarks_68.append(landmark) + num_detected_face += 1 + + return num_detected_face + + def warp_crop_faces(self, save_cropped_path=None, save_inverse_affine_path=None): + """Get affine matrix, warp and cropped faces. + + Also get inverse affine matrix for post-processing. + """ + for idx, landmark in enumerate(self.all_landmarks_5): + # use 5 landmarks to get affine matrix + self.similarity_trans.estimate(landmark, self.face_template) + affine_matrix = self.similarity_trans.params[0:2, :] + self.affine_matrices.append(affine_matrix) + # warp and crop faces + cropped_face = cv2.warpAffine(self.input_img, affine_matrix, self.face_size) + self.cropped_faces.append(cropped_face) + # save the cropped face + if save_cropped_path is not None: + path, ext = os.path.splitext(save_cropped_path) + if self.save_png: + save_path = f'{path}_{idx:02d}.png' + else: + save_path = f'{path}_{idx:02d}{ext}' + + imwrite(cv2.cvtColor(cropped_face, cv2.COLOR_RGB2BGR), save_path) + + # get inverse affine matrix + self.similarity_trans.estimate(self.face_template, landmark * self.upscale_factor) + inverse_affine = self.similarity_trans.params[0:2, :] + self.inverse_affine_matrices.append(inverse_affine) + # save inverse affine matrices + if save_inverse_affine_path is not None: + path, _ = os.path.splitext(save_inverse_affine_path) + save_path = f'{path}_{idx:02d}.pth' + torch.save(inverse_affine, save_path) + + def add_restored_face(self, face): + self.restored_faces.append(face) + + def paste_faces_to_input_image(self, save_path): + # operate in the BGR order + input_img = cv2.cvtColor(self.input_img, cv2.COLOR_RGB2BGR) + h, w, _ = input_img.shape + h_up, w_up = h * self.upscale_factor, w * self.upscale_factor + # simply resize the background + upsample_img = cv2.resize(input_img, (w_up, h_up)) + assert len(self.restored_faces) == len( + self.inverse_affine_matrices), ('length of restored_faces and affine_matrices are different.') + for restored_face, inverse_affine in zip(self.restored_faces, self.inverse_affine_matrices): + inv_restored = cv2.warpAffine(restored_face, inverse_affine, (w_up, h_up)) + mask = np.ones((*self.face_size, 3), dtype=np.float32) + inv_mask = cv2.warpAffine(mask, inverse_affine, (w_up, h_up)) + # remove the black borders + inv_mask_erosion = cv2.erode(inv_mask, np.ones((2 * self.upscale_factor, 2 * self.upscale_factor), + np.uint8)) + inv_restored_remove_border = inv_mask_erosion * inv_restored + total_face_area = np.sum(inv_mask_erosion) // 3 + # compute the fusion edge based on the area of face + w_edge = int(total_face_area**0.5) // 20 + erosion_radius = w_edge * 2 + inv_mask_center = cv2.erode(inv_mask_erosion, np.ones((erosion_radius, erosion_radius), np.uint8)) + blur_size = w_edge * 2 + inv_soft_mask = cv2.GaussianBlur(inv_mask_center, (blur_size + 1, blur_size + 1), 0) + upsample_img = inv_soft_mask * inv_restored_remove_border + (1 - inv_soft_mask) * upsample_img + if self.save_png: + save_path = save_path.replace('.jpg', '.png').replace('.jpeg', '.png') + imwrite(upsample_img.astype(np.uint8), save_path) + + def clean_all(self): + self.all_landmarks_5 = [] + self.all_landmarks_68 = [] + self.restored_faces = [] + self.affine_matrices = [] + self.cropped_faces = [] + self.inverse_affine_matrices = [] diff --git a/basicsr/utils/file_client.py b/basicsr/utils/file_client.py new file mode 100644 index 0000000000000000000000000000000000000000..bb6286a6556c85a29589b054a532200340f4a745 --- /dev/null +++ b/basicsr/utils/file_client.py @@ -0,0 +1,167 @@ +# Modified from https://github.com/open-mmlab/mmcv/blob/master/mmcv/fileio/file_client.py # noqa: E501 +from abc import ABCMeta, abstractmethod + + +class BaseStorageBackend(metaclass=ABCMeta): + """Abstract class of storage backends. + + All backends need to implement two apis: ``get()`` and ``get_text()``. + ``get()`` reads the file as a byte stream and ``get_text()`` reads the file + as texts. + """ + + @abstractmethod + def get(self, filepath): + pass + + @abstractmethod + def get_text(self, filepath): + pass + + +class MemcachedBackend(BaseStorageBackend): + """Memcached storage backend. + + Attributes: + server_list_cfg (str): Config file for memcached server list. + client_cfg (str): Config file for memcached client. + sys_path (str | None): Additional path to be appended to `sys.path`. + Default: None. + """ + + def __init__(self, server_list_cfg, client_cfg, sys_path=None): + if sys_path is not None: + import sys + sys.path.append(sys_path) + try: + import mc + except ImportError: + raise ImportError('Please install memcached to enable MemcachedBackend.') + + self.server_list_cfg = server_list_cfg + self.client_cfg = client_cfg + self._client = mc.MemcachedClient.GetInstance(self.server_list_cfg, self.client_cfg) + # mc.pyvector servers as a point which points to a memory cache + self._mc_buffer = mc.pyvector() + + def get(self, filepath): + filepath = str(filepath) + import mc + self._client.Get(filepath, self._mc_buffer) + value_buf = mc.ConvertBuffer(self._mc_buffer) + return value_buf + + def get_text(self, filepath): + raise NotImplementedError + + +class HardDiskBackend(BaseStorageBackend): + """Raw hard disks storage backend.""" + + def get(self, filepath): + filepath = str(filepath) + with open(filepath, 'rb') as f: + value_buf = f.read() + return value_buf + + def get_text(self, filepath): + filepath = str(filepath) + with open(filepath, 'r') as f: + value_buf = f.read() + return value_buf + + +class LmdbBackend(BaseStorageBackend): + """Lmdb storage backend. + + Args: + db_paths (str | list[str]): Lmdb database paths. + client_keys (str | list[str]): Lmdb client keys. Default: 'default'. + readonly (bool, optional): Lmdb environment parameter. If True, + disallow any write operations. Default: True. + lock (bool, optional): Lmdb environment parameter. If False, when + concurrent access occurs, do not lock the database. Default: False. + readahead (bool, optional): Lmdb environment parameter. If False, + disable the OS filesystem readahead mechanism, which may improve + random read performance when a database is larger than RAM. + Default: False. + + Attributes: + db_paths (list): Lmdb database path. + _client (list): A list of several lmdb envs. + """ + + def __init__(self, db_paths, client_keys='default', readonly=True, lock=False, readahead=False, **kwargs): + try: + import lmdb + except ImportError: + raise ImportError('Please install lmdb to enable LmdbBackend.') + + if isinstance(client_keys, str): + client_keys = [client_keys] + + if isinstance(db_paths, list): + self.db_paths = [str(v) for v in db_paths] + elif isinstance(db_paths, str): + self.db_paths = [str(db_paths)] + assert len(client_keys) == len(self.db_paths), ('client_keys and db_paths should have the same length, ' + f'but received {len(client_keys)} and {len(self.db_paths)}.') + + self._client = {} + for client, path in zip(client_keys, self.db_paths): + self._client[client] = lmdb.open(path, readonly=readonly, lock=lock, readahead=readahead, **kwargs) + + def get(self, filepath, client_key): + """Get values according to the filepath from one lmdb named client_key. + + Args: + filepath (str | obj:`Path`): Here, filepath is the lmdb key. + client_key (str): Used for distinguishing different lmdb envs. + """ + filepath = str(filepath) + assert client_key in self._client, (f'client_key {client_key} is not ' 'in lmdb clients.') + client = self._client[client_key] + with client.begin(write=False) as txn: + value_buf = txn.get(filepath.encode('ascii')) + return value_buf + + def get_text(self, filepath): + raise NotImplementedError + + +class FileClient(object): + """A general file client to access files in different backend. + + The client loads a file or text in a specified backend from its path + and return it as a binary file. it can also register other backend + accessor with a given name and backend class. + + Attributes: + backend (str): The storage backend type. Options are "disk", + "memcached" and "lmdb". + client (:obj:`BaseStorageBackend`): The backend object. + """ + + _backends = { + 'disk': HardDiskBackend, + 'memcached': MemcachedBackend, + 'lmdb': LmdbBackend, + } + + def __init__(self, backend='disk', **kwargs): + if backend not in self._backends: + raise ValueError(f'Backend {backend} is not supported. Currently supported ones' + f' are {list(self._backends.keys())}') + self.backend = backend + self.client = self._backends[backend](**kwargs) + + def get(self, filepath, client_key='default'): + # client_key is used only for lmdb, where different fileclients have + # different lmdb environments. + if self.backend == 'lmdb': + return self.client.get(filepath, client_key) + else: + return self.client.get(filepath) + + def get_text(self, filepath): + return self.client.get_text(filepath) diff --git a/basicsr/utils/flow_util.py b/basicsr/utils/flow_util.py new file mode 100644 index 0000000000000000000000000000000000000000..cb89d0e0f87651d9125eaecf7796e853044b487a --- /dev/null +++ b/basicsr/utils/flow_util.py @@ -0,0 +1,170 @@ +# Modified from https://github.com/open-mmlab/mmcv/blob/master/mmcv/video/optflow.py # noqa: E501 +import cv2 +import numpy as np +import os + + +def flowread(flow_path, quantize=False, concat_axis=0, *args, **kwargs): + """Read an optical flow map. + + Args: + flow_path (ndarray or str): Flow path. + quantize (bool): whether to read quantized pair, if set to True, + remaining args will be passed to :func:`dequantize_flow`. + concat_axis (int): The axis that dx and dy are concatenated, + can be either 0 or 1. Ignored if quantize is False. + + Returns: + ndarray: Optical flow represented as a (h, w, 2) numpy array + """ + if quantize: + assert concat_axis in [0, 1] + cat_flow = cv2.imread(flow_path, cv2.IMREAD_UNCHANGED) + if cat_flow.ndim != 2: + raise IOError(f'{flow_path} is not a valid quantized flow file, its dimension is {cat_flow.ndim}.') + assert cat_flow.shape[concat_axis] % 2 == 0 + dx, dy = np.split(cat_flow, 2, axis=concat_axis) + flow = dequantize_flow(dx, dy, *args, **kwargs) + else: + with open(flow_path, 'rb') as f: + try: + header = f.read(4).decode('utf-8') + except Exception: + raise IOError(f'Invalid flow file: {flow_path}') + else: + if header != 'PIEH': + raise IOError(f'Invalid flow file: {flow_path}, ' 'header does not contain PIEH') + + w = np.fromfile(f, np.int32, 1).squeeze() + h = np.fromfile(f, np.int32, 1).squeeze() + flow = np.fromfile(f, np.float32, w * h * 2).reshape((h, w, 2)) + + return flow.astype(np.float32) + + +def flowwrite(flow, filename, quantize=False, concat_axis=0, *args, **kwargs): + """Write optical flow to file. + + If the flow is not quantized, it will be saved as a .flo file losslessly, + otherwise a jpeg image which is lossy but of much smaller size. (dx and dy + will be concatenated horizontally into a single image if quantize is True.) + + Args: + flow (ndarray): (h, w, 2) array of optical flow. + filename (str): Output filepath. + quantize (bool): Whether to quantize the flow and save it to 2 jpeg + images. If set to True, remaining args will be passed to + :func:`quantize_flow`. + concat_axis (int): The axis that dx and dy are concatenated, + can be either 0 or 1. Ignored if quantize is False. + """ + if not quantize: + with open(filename, 'wb') as f: + f.write('PIEH'.encode('utf-8')) + np.array([flow.shape[1], flow.shape[0]], dtype=np.int32).tofile(f) + flow = flow.astype(np.float32) + flow.tofile(f) + f.flush() + else: + assert concat_axis in [0, 1] + dx, dy = quantize_flow(flow, *args, **kwargs) + dxdy = np.concatenate((dx, dy), axis=concat_axis) + os.makedirs(os.path.dirname(filename), exist_ok=True) + cv2.imwrite(filename, dxdy) + + +def quantize_flow(flow, max_val=0.02, norm=True): + """Quantize flow to [0, 255]. + + After this step, the size of flow will be much smaller, and can be + dumped as jpeg images. + + Args: + flow (ndarray): (h, w, 2) array of optical flow. + max_val (float): Maximum value of flow, values beyond + [-max_val, max_val] will be truncated. + norm (bool): Whether to divide flow values by image width/height. + + Returns: + tuple[ndarray]: Quantized dx and dy. + """ + h, w, _ = flow.shape + dx = flow[..., 0] + dy = flow[..., 1] + if norm: + dx = dx / w # avoid inplace operations + dy = dy / h + # use 255 levels instead of 256 to make sure 0 is 0 after dequantization. + flow_comps = [quantize(d, -max_val, max_val, 255, np.uint8) for d in [dx, dy]] + return tuple(flow_comps) + + +def dequantize_flow(dx, dy, max_val=0.02, denorm=True): + """Recover from quantized flow. + + Args: + dx (ndarray): Quantized dx. + dy (ndarray): Quantized dy. + max_val (float): Maximum value used when quantizing. + denorm (bool): Whether to multiply flow values with width/height. + + Returns: + ndarray: Dequantized flow. + """ + assert dx.shape == dy.shape + assert dx.ndim == 2 or (dx.ndim == 3 and dx.shape[-1] == 1) + + dx, dy = [dequantize(d, -max_val, max_val, 255) for d in [dx, dy]] + + if denorm: + dx *= dx.shape[1] + dy *= dx.shape[0] + flow = np.dstack((dx, dy)) + return flow + + +def quantize(arr, min_val, max_val, levels, dtype=np.int64): + """Quantize an array of (-inf, inf) to [0, levels-1]. + + Args: + arr (ndarray): Input array. + min_val (scalar): Minimum value to be clipped. + max_val (scalar): Maximum value to be clipped. + levels (int): Quantization levels. + dtype (np.type): The type of the quantized array. + + Returns: + tuple: Quantized array. + """ + if not (isinstance(levels, int) and levels > 1): + raise ValueError(f'levels must be a positive integer, but got {levels}') + if min_val >= max_val: + raise ValueError(f'min_val ({min_val}) must be smaller than max_val ({max_val})') + + arr = np.clip(arr, min_val, max_val) - min_val + quantized_arr = np.minimum(np.floor(levels * arr / (max_val - min_val)).astype(dtype), levels - 1) + + return quantized_arr + + +def dequantize(arr, min_val, max_val, levels, dtype=np.float64): + """Dequantize an array. + + Args: + arr (ndarray): Input array. + min_val (scalar): Minimum value to be clipped. + max_val (scalar): Maximum value to be clipped. + levels (int): Quantization levels. + dtype (np.type): The type of the dequantized array. + + Returns: + tuple: Dequantized array. + """ + if not (isinstance(levels, int) and levels > 1): + raise ValueError(f'levels must be a positive integer, but got {levels}') + if min_val >= max_val: + raise ValueError(f'min_val ({min_val}) must be smaller than max_val ({max_val})') + + dequantized_arr = (arr + 0.5).astype(dtype) * (max_val - min_val) / levels + min_val + + return dequantized_arr diff --git a/basicsr/utils/img_process_util.py b/basicsr/utils/img_process_util.py new file mode 100644 index 0000000000000000000000000000000000000000..52e02f09930dbf13bcd12bbe16b76e4fce52578e --- /dev/null +++ b/basicsr/utils/img_process_util.py @@ -0,0 +1,83 @@ +import cv2 +import numpy as np +import torch +from torch.nn import functional as F + + +def filter2D(img, kernel): + """PyTorch version of cv2.filter2D + + Args: + img (Tensor): (b, c, h, w) + kernel (Tensor): (b, k, k) + """ + k = kernel.size(-1) + b, c, h, w = img.size() + if k % 2 == 1: + img = F.pad(img, (k // 2, k // 2, k // 2, k // 2), mode='reflect') + else: + raise ValueError('Wrong kernel size') + + ph, pw = img.size()[-2:] + + if kernel.size(0) == 1: + # apply the same kernel to all batch images + img = img.view(b * c, 1, ph, pw) + kernel = kernel.view(1, 1, k, k) + return F.conv2d(img, kernel, padding=0).view(b, c, h, w) + else: + img = img.view(1, b * c, ph, pw) + kernel = kernel.view(b, 1, k, k).repeat(1, c, 1, 1).view(b * c, 1, k, k) + return F.conv2d(img, kernel, groups=b * c).view(b, c, h, w) + + +def usm_sharp(img, weight=0.5, radius=50, threshold=10): + """USM sharpening. + + Input image: I; Blurry image: B. + 1. sharp = I + weight * (I - B) + 2. Mask = 1 if abs(I - B) > threshold, else: 0 + 3. Blur mask: + 4. Out = Mask * sharp + (1 - Mask) * I + + + Args: + img (Numpy array): Input image, HWC, BGR; float32, [0, 1]. + weight (float): Sharp weight. Default: 1. + radius (float): Kernel size of Gaussian blur. Default: 50. + threshold (int): + """ + if radius % 2 == 0: + radius += 1 + blur = cv2.GaussianBlur(img, (radius, radius), 0) + residual = img - blur + mask = np.abs(residual) * 255 > threshold + mask = mask.astype('float32') + soft_mask = cv2.GaussianBlur(mask, (radius, radius), 0) + + sharp = img + weight * residual + sharp = np.clip(sharp, 0, 1) + return soft_mask * sharp + (1 - soft_mask) * img + + +class USMSharp(torch.nn.Module): + + def __init__(self, radius=50, sigma=0): + super(USMSharp, self).__init__() + if radius % 2 == 0: + radius += 1 + self.radius = radius + kernel = cv2.getGaussianKernel(radius, sigma) + kernel = torch.FloatTensor(np.dot(kernel, kernel.transpose())).unsqueeze_(0) + self.register_buffer('kernel', kernel) + + def forward(self, img, weight=0.5, threshold=10): + blur = filter2D(img, self.kernel) + residual = img - blur + + mask = torch.abs(residual) * 255 > threshold + mask = mask.float() + soft_mask = filter2D(mask, self.kernel) + sharp = img + weight * residual + sharp = torch.clip(sharp, 0, 1) + return soft_mask * sharp + (1 - soft_mask) * img diff --git a/basicsr/utils/img_util.py b/basicsr/utils/img_util.py new file mode 100644 index 0000000000000000000000000000000000000000..921bcb0e33093b480924d75d27706dc38783554b --- /dev/null +++ b/basicsr/utils/img_util.py @@ -0,0 +1,227 @@ +import cv2 +import math +import numpy as np +import os +import torch +from torchvision.utils import make_grid + + +def img2tensor(imgs, bgr2rgb=True, float32=True): + """Numpy array to tensor. + + Args: + imgs (list[ndarray] | ndarray): Input images. + bgr2rgb (bool): Whether to change bgr to rgb. + float32 (bool): Whether to change to float32. + + Returns: + list[tensor] | tensor: Tensor images. If returned results only have + one element, just return tensor. + """ + + def _totensor(img, bgr2rgb, float32): + if img.shape[2] == 3 and bgr2rgb: + if img.dtype == 'float64': + img = img.astype('float32') + img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) + img = torch.from_numpy(img.transpose(2, 0, 1)) + if float32: + img = img.float() + return img + + if isinstance(imgs, list): + return [_totensor(img, bgr2rgb, float32) for img in imgs] + else: + return _totensor(imgs, bgr2rgb, float32) + + +def tensor2img(tensor, rgb2bgr=True, out_type=np.uint8, min_max=(0, 1)): + """Convert torch Tensors into image numpy arrays. + + After clamping to [min, max], values will be normalized to [0, 1]. + + Args: + tensor (Tensor or list[Tensor]): Accept shapes: + 1) 4D mini-batch Tensor of shape (B x 3/1 x H x W); + 2) 3D Tensor of shape (3/1 x H x W); + 3) 2D Tensor of shape (H x W). + Tensor channel should be in RGB order. + rgb2bgr (bool): Whether to change rgb to bgr. + out_type (numpy type): output types. If ``np.uint8``, transform outputs + to uint8 type with range [0, 255]; otherwise, float type with + range [0, 1]. Default: ``np.uint8``. + min_max (tuple[int]): min and max values for clamp. + + Returns: + (Tensor or list): 3D ndarray of shape (H x W x C) OR 2D ndarray of + shape (H x W). The channel order is BGR. + """ + if not (torch.is_tensor(tensor) or (isinstance(tensor, list) and all(torch.is_tensor(t) for t in tensor))): + raise TypeError(f'tensor or list of tensors expected, got {type(tensor)}') + + if torch.is_tensor(tensor): + tensor = [tensor] + result = [] + for _tensor in tensor: + _tensor = _tensor.squeeze(0).float().detach().cpu().clamp_(*min_max) + _tensor = (_tensor - min_max[0]) / (min_max[1] - min_max[0]) + + n_dim = _tensor.dim() + if n_dim == 4: + img_np = make_grid(_tensor, nrow=int(math.sqrt(_tensor.size(0))), normalize=False).numpy() + img_np = img_np.transpose(1, 2, 0) + if rgb2bgr: + img_np = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR) + elif n_dim == 3: + img_np = _tensor.numpy() + img_np = img_np.transpose(1, 2, 0) + if img_np.shape[2] == 1: # gray image + img_np = np.squeeze(img_np, axis=2) + else: + if rgb2bgr: + img_np = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR) + elif n_dim == 2: + img_np = _tensor.numpy() + else: + raise TypeError(f'Only support 4D, 3D or 2D tensor. But received with dimension: {n_dim}') + if out_type == np.uint8: + # Unlike MATLAB, numpy.unit8() WILL NOT round by default. + img_np = (img_np * 255.0).round() + img_np = img_np.astype(out_type) + result.append(img_np) + if len(result) == 1: + result = result[0] + return result + + +def tensor2img_fast(tensor, rgb2bgr=True, min_max=(0, 1)): + """This implementation is slightly faster than tensor2img. + It now only supports torch tensor with shape (1, c, h, w). + + Args: + tensor (Tensor): Now only support torch tensor with (1, c, h, w). + rgb2bgr (bool): Whether to change rgb to bgr. Default: True. + min_max (tuple[int]): min and max values for clamp. + """ + output = tensor.squeeze(0).detach().clamp_(*min_max).permute(1, 2, 0) + output = (output - min_max[0]) / (min_max[1] - min_max[0]) * 255 + output = output.type(torch.uint8).cpu().numpy() + if rgb2bgr: + output = cv2.cvtColor(output, cv2.COLOR_RGB2BGR) + return output + + +def imfrombytes(content, flag='color', float32=False): + """Read an image from bytes. + + Args: + content (bytes): Image bytes got from files or other streams. + flag (str): Flags specifying the color type of a loaded image, + candidates are `color`, `grayscale` and `unchanged`. + float32 (bool): Whether to change to float32., If True, will also norm + to [0, 1]. Default: False. + + Returns: + ndarray: Loaded image array. + """ + img_np = np.frombuffer(content, np.uint8) + imread_flags = {'color': cv2.IMREAD_COLOR, 'grayscale': cv2.IMREAD_GRAYSCALE, 'unchanged': cv2.IMREAD_UNCHANGED} + img = cv2.imdecode(img_np, imread_flags[flag]) + if float32: + img = img.astype(np.float32) / 255. + return img + + +def imwrite(img, file_path, params=None, auto_mkdir=True): + """Write image to file. + + Args: + img (ndarray): Image array to be written. + file_path (str): Image file path. + params (None or list): Same as opencv's :func:`imwrite` interface. + auto_mkdir (bool): If the parent folder of `file_path` does not exist, + whether to create it automatically. + + Returns: + bool: Successful or not. + """ + if auto_mkdir: + dir_name = os.path.abspath(os.path.dirname(file_path)) + os.makedirs(dir_name, exist_ok=True) + ok = cv2.imwrite(file_path, img, params) + if not ok: + raise IOError('Failed in writing images.') + + +def crop_border(imgs, crop_border): + """Crop borders of images. + + Args: + imgs (list[ndarray] | ndarray): Images with shape (h, w, c). + crop_border (int): Crop border for each end of height and weight. + + Returns: + list[ndarray]: Cropped images. + """ + if crop_border == 0: + return imgs + else: + if isinstance(imgs, list): + return [v[crop_border:-crop_border, crop_border:-crop_border, ...] for v in imgs] + else: + return imgs[crop_border:-crop_border, crop_border:-crop_border, ...] + + +def tensor_lab2rgb(labs, illuminant="D65", observer="2"): + """ + Args: + lab : (B, C, H, W) + Returns: + tuple : (C, H, W) + """ + illuminants = \ + {"A": {'2': (1.098466069456375, 1, 0.3558228003436005), + '10': (1.111420406956693, 1, 0.3519978321919493)}, + "D50": {'2': (0.9642119944211994, 1, 0.8251882845188288), + '10': (0.9672062750333777, 1, 0.8142801513128616)}, + "D55": {'2': (0.956797052643698, 1, 0.9214805860173273), + '10': (0.9579665682254781, 1, 0.9092525159847462)}, + "D65": {'2': (0.95047, 1., 1.08883), # This was: `lab_ref_white` + '10': (0.94809667673716, 1, 1.0730513595166162)}, + "D75": {'2': (0.9497220898840717, 1, 1.226393520724154), + '10': (0.9441713925645873, 1, 1.2064272211720228)}, + "E": {'2': (1.0, 1.0, 1.0), + '10': (1.0, 1.0, 1.0)}} + xyz_from_rgb = np.array([[0.412453, 0.357580, 0.180423], [0.212671, 0.715160, 0.072169], + [0.019334, 0.119193, 0.950227]]) + + rgb_from_xyz = np.array([[3.240481340, -0.96925495, 0.055646640], [-1.53715152, 1.875990000, -0.20404134], + [-0.49853633, 0.041555930, 1.057311070]]) + B, C, H, W = labs.shape + arrs = labs.permute((0, 2, 3, 1)).contiguous() # (B, 3, H, W) -> (B, H, W, 3) + L, a, b = arrs[:, :, :, 0:1], arrs[:, :, :, 1:2], arrs[:, :, :, 2:] + y = (L + 16.) / 116. + x = (a / 500.) + y + z = y - (b / 200.) + invalid = z.data < 0 + z[invalid] = 0 + xyz = torch.cat([x, y, z], dim=3) + mask = xyz.data > 0.2068966 + mask_xyz = xyz.clone() + mask_xyz[mask] = torch.pow(xyz[mask], 3.0) + mask_xyz[~mask] = (xyz[~mask] - 16.0 / 116.) / 7.787 + xyz_ref_white = illuminants[illuminant][observer] + for i in range(C): + mask_xyz[:, :, :, i] = mask_xyz[:, :, :, i] * xyz_ref_white[i] + + rgb_trans = torch.mm(mask_xyz.view(-1, 3), torch.from_numpy(rgb_from_xyz).type_as(xyz)).view(B, H, W, C) + rgb = rgb_trans.permute((0, 3, 1, 2)).contiguous() + mask = rgb.data > 0.0031308 + mask_rgb = rgb.clone() + mask_rgb[mask] = 1.055 * torch.pow(rgb[mask], 1 / 2.4) - 0.055 + mask_rgb[~mask] = rgb[~mask] * 12.92 + neg_mask = mask_rgb.data < 0 + large_mask = mask_rgb.data > 1 + mask_rgb[neg_mask] = 0 + mask_rgb[large_mask] = 1 + return mask_rgb \ No newline at end of file diff --git a/basicsr/utils/lmdb_util.py b/basicsr/utils/lmdb_util.py new file mode 100644 index 0000000000000000000000000000000000000000..e0a10f60ffca2e36ac5f5564aafd70e79d06a723 --- /dev/null +++ b/basicsr/utils/lmdb_util.py @@ -0,0 +1,196 @@ +import cv2 +import lmdb +import sys +from multiprocessing import Pool +from os import path as osp +from tqdm import tqdm + + +def make_lmdb_from_imgs(data_path, + lmdb_path, + img_path_list, + keys, + batch=5000, + compress_level=1, + multiprocessing_read=False, + n_thread=40, + map_size=None): + """Make lmdb from images. + + Contents of lmdb. The file structure is: + example.lmdb + ├── data.mdb + ├── lock.mdb + ├── meta_info.txt + + The data.mdb and lock.mdb are standard lmdb files and you can refer to + https://lmdb.readthedocs.io/en/release/ for more details. + + The meta_info.txt is a specified txt file to record the meta information + of our datasets. It will be automatically created when preparing + datasets by our provided dataset tools. + Each line in the txt file records 1)image name (with extension), + 2)image shape, and 3)compression level, separated by a white space. + + For example, the meta information could be: + `000_00000000.png (720,1280,3) 1`, which means: + 1) image name (with extension): 000_00000000.png; + 2) image shape: (720,1280,3); + 3) compression level: 1 + + We use the image name without extension as the lmdb key. + + If `multiprocessing_read` is True, it will read all the images to memory + using multiprocessing. Thus, your server needs to have enough memory. + + Args: + data_path (str): Data path for reading images. + lmdb_path (str): Lmdb save path. + img_path_list (str): Image path list. + keys (str): Used for lmdb keys. + batch (int): After processing batch images, lmdb commits. + Default: 5000. + compress_level (int): Compress level when encoding images. Default: 1. + multiprocessing_read (bool): Whether use multiprocessing to read all + the images to memory. Default: False. + n_thread (int): For multiprocessing. + map_size (int | None): Map size for lmdb env. If None, use the + estimated size from images. Default: None + """ + + assert len(img_path_list) == len(keys), ('img_path_list and keys should have the same length, ' + f'but got {len(img_path_list)} and {len(keys)}') + print(f'Create lmdb for {data_path}, save to {lmdb_path}...') + print(f'Totoal images: {len(img_path_list)}') + if not lmdb_path.endswith('.lmdb'): + raise ValueError("lmdb_path must end with '.lmdb'.") + if osp.exists(lmdb_path): + print(f'Folder {lmdb_path} already exists. Exit.') + sys.exit(1) + + if multiprocessing_read: + # read all the images to memory (multiprocessing) + dataset = {} # use dict to keep the order for multiprocessing + shapes = {} + print(f'Read images with multiprocessing, #thread: {n_thread} ...') + pbar = tqdm(total=len(img_path_list), unit='image') + + def callback(arg): + """get the image data and update pbar.""" + key, dataset[key], shapes[key] = arg + pbar.update(1) + pbar.set_description(f'Read {key}') + + pool = Pool(n_thread) + for path, key in zip(img_path_list, keys): + pool.apply_async(read_img_worker, args=(osp.join(data_path, path), key, compress_level), callback=callback) + pool.close() + pool.join() + pbar.close() + print(f'Finish reading {len(img_path_list)} images.') + + # create lmdb environment + if map_size is None: + # obtain data size for one image + img = cv2.imread(osp.join(data_path, img_path_list[0]), cv2.IMREAD_UNCHANGED) + _, img_byte = cv2.imencode('.png', img, [cv2.IMWRITE_PNG_COMPRESSION, compress_level]) + data_size_per_img = img_byte.nbytes + print('Data size per image is: ', data_size_per_img) + data_size = data_size_per_img * len(img_path_list) + map_size = data_size * 10 + + env = lmdb.open(lmdb_path, map_size=map_size) + + # write data to lmdb + pbar = tqdm(total=len(img_path_list), unit='chunk') + txn = env.begin(write=True) + txt_file = open(osp.join(lmdb_path, 'meta_info.txt'), 'w') + for idx, (path, key) in enumerate(zip(img_path_list, keys)): + pbar.update(1) + pbar.set_description(f'Write {key}') + key_byte = key.encode('ascii') + if multiprocessing_read: + img_byte = dataset[key] + h, w, c = shapes[key] + else: + _, img_byte, img_shape = read_img_worker(osp.join(data_path, path), key, compress_level) + h, w, c = img_shape + + txn.put(key_byte, img_byte) + # write meta information + txt_file.write(f'{key}.png ({h},{w},{c}) {compress_level}\n') + if idx % batch == 0: + txn.commit() + txn = env.begin(write=True) + pbar.close() + txn.commit() + env.close() + txt_file.close() + print('\nFinish writing lmdb.') + + +def read_img_worker(path, key, compress_level): + """Read image worker. + + Args: + path (str): Image path. + key (str): Image key. + compress_level (int): Compress level when encoding images. + + Returns: + str: Image key. + byte: Image byte. + tuple[int]: Image shape. + """ + + img = cv2.imread(path, cv2.IMREAD_UNCHANGED) + if img.ndim == 2: + h, w = img.shape + c = 1 + else: + h, w, c = img.shape + _, img_byte = cv2.imencode('.png', img, [cv2.IMWRITE_PNG_COMPRESSION, compress_level]) + return (key, img_byte, (h, w, c)) + + +class LmdbMaker(): + """LMDB Maker. + + Args: + lmdb_path (str): Lmdb save path. + map_size (int): Map size for lmdb env. Default: 1024 ** 4, 1TB. + batch (int): After processing batch images, lmdb commits. + Default: 5000. + compress_level (int): Compress level when encoding images. Default: 1. + """ + + def __init__(self, lmdb_path, map_size=1024**4, batch=5000, compress_level=1): + if not lmdb_path.endswith('.lmdb'): + raise ValueError("lmdb_path must end with '.lmdb'.") + if osp.exists(lmdb_path): + print(f'Folder {lmdb_path} already exists. Exit.') + sys.exit(1) + + self.lmdb_path = lmdb_path + self.batch = batch + self.compress_level = compress_level + self.env = lmdb.open(lmdb_path, map_size=map_size) + self.txn = self.env.begin(write=True) + self.txt_file = open(osp.join(lmdb_path, 'meta_info.txt'), 'w') + self.counter = 0 + + def put(self, img_byte, key, img_shape): + self.counter += 1 + key_byte = key.encode('ascii') + self.txn.put(key_byte, img_byte) + # write meta information + h, w, c = img_shape + self.txt_file.write(f'{key}.png ({h},{w},{c}) {self.compress_level}\n') + if self.counter % self.batch == 0: + self.txn.commit() + self.txn = self.env.begin(write=True) + + def close(self): + self.txn.commit() + self.env.close() + self.txt_file.close() diff --git a/basicsr/utils/logger.py b/basicsr/utils/logger.py new file mode 100644 index 0000000000000000000000000000000000000000..2e1dd13b423a0b9a4cee6ffe0f1213c995068b16 --- /dev/null +++ b/basicsr/utils/logger.py @@ -0,0 +1,209 @@ +import datetime +import logging +import time + +from .dist_util import get_dist_info, master_only + +initialized_logger = {} + + +class AvgTimer(): + + def __init__(self, window=200): + self.window = window # average window + self.current_time = 0 + self.total_time = 0 + self.count = 0 + self.avg_time = 0 + self.start() + + def start(self): + self.start_time = time.time() + + def record(self): + self.count += 1 + self.current_time = time.time() - self.start_time + self.total_time += self.current_time + # calculate average time + self.avg_time = self.total_time / self.count + # reset + if self.count > self.window: + self.count = 0 + self.total_time = 0 + + def get_current_time(self): + return self.current_time + + def get_avg_time(self): + return self.avg_time + + +class MessageLogger(): + """Message logger for printing. + + Args: + opt (dict): Config. It contains the following keys: + name (str): Exp name. + logger (dict): Contains 'print_freq' (str) for logger interval. + train (dict): Contains 'total_iter' (int) for total iters. + use_tb_logger (bool): Use tensorboard logger. + start_iter (int): Start iter. Default: 1. + tb_logger (obj:`tb_logger`): Tensorboard logger. Default： None. + """ + + def __init__(self, opt, start_iter=1, tb_logger=None): + self.exp_name = opt['name'] + self.interval = opt['logger']['print_freq'] + self.start_iter = start_iter + self.max_iters = opt['train']['total_iter'] + self.use_tb_logger = opt['logger']['use_tb_logger'] + self.tb_logger = tb_logger + self.start_time = time.time() + self.logger = get_root_logger() + + def reset_start_time(self): + self.start_time = time.time() + + @master_only + def __call__(self, log_vars): + """Format logging message. + + Args: + log_vars (dict): It contains the following keys: + epoch (int): Epoch number. + iter (int): Current iter. + lrs (list): List for learning rates. + + time (float): Iter time. + data_time (float): Data time for each iter. + """ + # epoch, iter, learning rates + epoch = log_vars.pop('epoch') + current_iter = log_vars.pop('iter') + lrs = log_vars.pop('lrs') + + message = (f'[{self.exp_name[:5]}..][epoch:{epoch:3d}, iter:{current_iter:8,d}, lr:(') + for v in lrs: + message += f'{v:.3e},' + message += ')] ' + + # time and estimated time + if 'time' in log_vars.keys(): + iter_time = log_vars.pop('time') + data_time = log_vars.pop('data_time') + + total_time = time.time() - self.start_time + time_sec_avg = total_time / (current_iter - self.start_iter + 1) + eta_sec = time_sec_avg * (self.max_iters - current_iter - 1) + eta_str = str(datetime.timedelta(seconds=int(eta_sec))) + message += f'[eta: {eta_str}, ' + message += f'time (data): {iter_time:.3f} ({data_time:.3f})] ' + + # other items, especially losses + for k, v in log_vars.items(): + message += f'{k}: {v:.4e} ' + # tensorboard logger + if self.use_tb_logger and 'debug' not in self.exp_name: + if k.startswith('l_'): + self.tb_logger.add_scalar(f'losses/{k}', v, current_iter) + else: + self.tb_logger.add_scalar(k, v, current_iter) + self.logger.info(message) + + +@master_only +def init_tb_logger(log_dir): + from torch.utils.tensorboard import SummaryWriter + tb_logger = SummaryWriter(log_dir=log_dir) + return tb_logger + + +@master_only +def init_wandb_logger(opt): + """We now only use wandb to sync tensorboard log.""" + import wandb + logger = get_root_logger() + + project = opt['logger']['wandb']['project'] + resume_id = opt['logger']['wandb'].get('resume_id') + if resume_id: + wandb_id = resume_id + resume = 'allow' + logger.warning(f'Resume wandb logger with id={wandb_id}.') + else: + wandb_id = wandb.util.generate_id() + resume = 'never' + + wandb.init(id=wandb_id, resume=resume, name=opt['name'], config=opt, project=project, sync_tensorboard=True) + + logger.info(f'Use wandb logger with id={wandb_id}; project={project}.') + + +def get_root_logger(logger_name='basicsr', log_level=logging.INFO, log_file=None): + """Get the root logger. + + The logger will be initialized if it has not been initialized. By default a + StreamHandler will be added. If `log_file` is specified, a FileHandler will + also be added. + + Args: + logger_name (str): root logger name. Default: 'basicsr'. + log_file (str | None): The log filename. If specified, a FileHandler + will be added to the root logger. + log_level (int): The root logger level. Note that only the process of + rank 0 is affected, while other processes will set the level to + "Error" and be silent most of the time. + + Returns: + logging.Logger: The root logger. + """ + logger = logging.getLogger(logger_name) + # if the logger has been initialized, just return it + if logger_name in initialized_logger: + return logger + + format_str = '%(asctime)s %(levelname)s: %(message)s' + stream_handler = logging.StreamHandler() + stream_handler.setFormatter(logging.Formatter(format_str)) + logger.addHandler(stream_handler) + logger.propagate = False + rank, _ = get_dist_info() + if rank != 0: + logger.setLevel('ERROR') + elif log_file is not None: + logger.setLevel(log_level) + # add file handler + file_handler = logging.FileHandler(log_file, 'w') + file_handler.setFormatter(logging.Formatter(format_str)) + file_handler.setLevel(log_level) + logger.addHandler(file_handler) + initialized_logger[logger_name] = True + return logger + + +def get_env_info(): + """Get environment information. + + Currently, only log the software version. + """ + import torch + import torchvision + + from basicsr.version import __version__ + msg = r""" + ____ _ _____ ____ + / __ ) ____ _ _____ (_)_____/ ___/ / __ \ + / __ |/ __ `// ___// // ___/\__ \ / /_/ / + / /_/ // /_/ /(__ )/ // /__ ___/ // _, _/ + /_____/ \__,_//____//_/ \___//____//_/ |_| + ______ __ __ __ __ + / ____/____ ____ ____/ / / / __ __ _____ / /__ / / + / / __ / __ \ / __ \ / __ / / / / / / // ___// //_/ / / + / /_/ // /_/ // /_/ // /_/ / / /___/ /_/ // /__ / /< /_/ + \____/ \____/ \____/ \____/ /_____/\____/ \___//_/|_| (_) + """ + msg += ('\nVersion Information: ' + f'\n\tBasicSR: {__version__}' + f'\n\tPyTorch: {torch.__version__}' + f'\n\tTorchVision: {torchvision.__version__}') + return msg diff --git a/basicsr/utils/matlab_functions.py b/basicsr/utils/matlab_functions.py new file mode 100644 index 0000000000000000000000000000000000000000..f9f1a83bc8beee468dd7c9ca734966e926fd9fde --- /dev/null +++ b/basicsr/utils/matlab_functions.py @@ -0,0 +1,359 @@ +import math +import numpy as np +import torch + + +def cubic(x): + """cubic function used for calculate_weights_indices.""" + absx = torch.abs(x) + absx2 = absx**2 + absx3 = absx**3 + return (1.5 * absx3 - 2.5 * absx2 + 1) * ( + (absx <= 1).type_as(absx)) + (-0.5 * absx3 + 2.5 * absx2 - 4 * absx + 2) * (((absx > 1) * + (absx <= 2)).type_as(absx)) + + +def calculate_weights_indices(in_length, out_length, scale, kernel, kernel_width, antialiasing): + """Calculate weights and indices, used for imresize function. + + Args: + in_length (int): Input length. + out_length (int): Output length. + scale (float): Scale factor. + kernel_width (int): Kernel width. + antialisaing (bool): Whether to apply anti-aliasing when downsampling. + """ + + if (scale < 1) and antialiasing: + # Use a modified kernel (larger kernel width) to simultaneously + # interpolate and antialias + kernel_width = kernel_width / scale + + # Output-space coordinates + x = torch.linspace(1, out_length, out_length) + + # Input-space coordinates. Calculate the inverse mapping such that 0.5 + # in output space maps to 0.5 in input space, and 0.5 + scale in output + # space maps to 1.5 in input space. + u = x / scale + 0.5 * (1 - 1 / scale) + + # What is the left-most pixel that can be involved in the computation? + left = torch.floor(u - kernel_width / 2) + + # What is the maximum number of pixels that can be involved in the + # computation? Note: it's OK to use an extra pixel here; if the + # corresponding weights are all zero, it will be eliminated at the end + # of this function. + p = math.ceil(kernel_width) + 2 + + # The indices of the input pixels involved in computing the k-th output + # pixel are in row k of the indices matrix. + indices = left.view(out_length, 1).expand(out_length, p) + torch.linspace(0, p - 1, p).view(1, p).expand( + out_length, p) + + # The weights used to compute the k-th output pixel are in row k of the + # weights matrix. + distance_to_center = u.view(out_length, 1).expand(out_length, p) - indices + + # apply cubic kernel + if (scale < 1) and antialiasing: + weights = scale * cubic(distance_to_center * scale) + else: + weights = cubic(distance_to_center) + + # Normalize the weights matrix so that each row sums to 1. + weights_sum = torch.sum(weights, 1).view(out_length, 1) + weights = weights / weights_sum.expand(out_length, p) + + # If a column in weights is all zero, get rid of it. only consider the + # first and last column. + weights_zero_tmp = torch.sum((weights == 0), 0) + if not math.isclose(weights_zero_tmp[0], 0, rel_tol=1e-6): + indices = indices.narrow(1, 1, p - 2) + weights = weights.narrow(1, 1, p - 2) + if not math.isclose(weights_zero_tmp[-1], 0, rel_tol=1e-6): + indices = indices.narrow(1, 0, p - 2) + weights = weights.narrow(1, 0, p - 2) + weights = weights.contiguous() + indices = indices.contiguous() + sym_len_s = -indices.min() + 1 + sym_len_e = indices.max() - in_length + indices = indices + sym_len_s - 1 + return weights, indices, int(sym_len_s), int(sym_len_e) + + +@torch.no_grad() +def imresize(img, scale, antialiasing=True): + """imresize function same as MATLAB. + + It now only supports bicubic. + The same scale applies for both height and width. + + Args: + img (Tensor | Numpy array): + Tensor: Input image with shape (c, h, w), [0, 1] range. + Numpy: Input image with shape (h, w, c), [0, 1] range. + scale (float): Scale factor. The same scale applies for both height + and width. + antialisaing (bool): Whether to apply anti-aliasing when downsampling. + Default: True. + + Returns: + Tensor: Output image with shape (c, h, w), [0, 1] range, w/o round. + """ + squeeze_flag = False + if type(img).__module__ == np.__name__: # numpy type + numpy_type = True + if img.ndim == 2: + img = img[:, :, None] + squeeze_flag = True + img = torch.from_numpy(img.transpose(2, 0, 1)).float() + else: + numpy_type = False + if img.ndim == 2: + img = img.unsqueeze(0) + squeeze_flag = True + + in_c, in_h, in_w = img.size() + out_h, out_w = math.ceil(in_h * scale), math.ceil(in_w * scale) + kernel_width = 4 + kernel = 'cubic' + + # get weights and indices + weights_h, indices_h, sym_len_hs, sym_len_he = calculate_weights_indices(in_h, out_h, scale, kernel, kernel_width, + antialiasing) + weights_w, indices_w, sym_len_ws, sym_len_we = calculate_weights_indices(in_w, out_w, scale, kernel, kernel_width, + antialiasing) + # process H dimension + # symmetric copying + img_aug = torch.FloatTensor(in_c, in_h + sym_len_hs + sym_len_he, in_w) + img_aug.narrow(1, sym_len_hs, in_h).copy_(img) + + sym_patch = img[:, :sym_len_hs, :] + inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long() + sym_patch_inv = sym_patch.index_select(1, inv_idx) + img_aug.narrow(1, 0, sym_len_hs).copy_(sym_patch_inv) + + sym_patch = img[:, -sym_len_he:, :] + inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long() + sym_patch_inv = sym_patch.index_select(1, inv_idx) + img_aug.narrow(1, sym_len_hs + in_h, sym_len_he).copy_(sym_patch_inv) + + out_1 = torch.FloatTensor(in_c, out_h, in_w) + kernel_width = weights_h.size(1) + for i in range(out_h): + idx = int(indices_h[i][0]) + for j in range(in_c): + out_1[j, i, :] = img_aug[j, idx:idx + kernel_width, :].transpose(0, 1).mv(weights_h[i]) + + # process W dimension + # symmetric copying + out_1_aug = torch.FloatTensor(in_c, out_h, in_w + sym_len_ws + sym_len_we) + out_1_aug.narrow(2, sym_len_ws, in_w).copy_(out_1) + + sym_patch = out_1[:, :, :sym_len_ws] + inv_idx = torch.arange(sym_patch.size(2) - 1, -1, -1).long() + sym_patch_inv = sym_patch.index_select(2, inv_idx) + out_1_aug.narrow(2, 0, sym_len_ws).copy_(sym_patch_inv) + + sym_patch = out_1[:, :, -sym_len_we:] + inv_idx = torch.arange(sym_patch.size(2) - 1, -1, -1).long() + sym_patch_inv = sym_patch.index_select(2, inv_idx) + out_1_aug.narrow(2, sym_len_ws + in_w, sym_len_we).copy_(sym_patch_inv) + + out_2 = torch.FloatTensor(in_c, out_h, out_w) + kernel_width = weights_w.size(1) + for i in range(out_w): + idx = int(indices_w[i][0]) + for j in range(in_c): + out_2[j, :, i] = out_1_aug[j, :, idx:idx + kernel_width].mv(weights_w[i]) + + if squeeze_flag: + out_2 = out_2.squeeze(0) + if numpy_type: + out_2 = out_2.numpy() + if not squeeze_flag: + out_2 = out_2.transpose(1, 2, 0) + + return out_2 + + +def rgb2ycbcr(img, y_only=False): + """Convert a RGB image to YCbCr image. + + This function produces the same results as Matlab's `rgb2ycbcr` function. + It implements the ITU-R BT.601 conversion for standard-definition + television. See more details in + https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion. + + It differs from a similar function in cv2.cvtColor: `RGB <-> YCrCb`. + In OpenCV, it implements a JPEG conversion. See more details in + https://en.wikipedia.org/wiki/YCbCr#JPEG_conversion. + + Args: + img (ndarray): The input image. It accepts: + 1. np.uint8 type with range [0, 255]; + 2. np.float32 type with range [0, 1]. + y_only (bool): Whether to only return Y channel. Default: False. + + Returns: + ndarray: The converted YCbCr image. The output image has the same type + and range as input image. + """ + img_type = img.dtype + img = _convert_input_type_range(img) + if y_only: + out_img = np.dot(img, [65.481, 128.553, 24.966]) + 16.0 + else: + out_img = np.matmul( + img, [[65.481, -37.797, 112.0], [128.553, -74.203, -93.786], [24.966, 112.0, -18.214]]) + [16, 128, 128] + out_img = _convert_output_type_range(out_img, img_type) + return out_img + + +def bgr2ycbcr(img, y_only=False): + """Convert a BGR image to YCbCr image. + + The bgr version of rgb2ycbcr. + It implements the ITU-R BT.601 conversion for standard-definition + television. See more details in + https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion. + + It differs from a similar function in cv2.cvtColor: `BGR <-> YCrCb`. + In OpenCV, it implements a JPEG conversion. See more details in + https://en.wikipedia.org/wiki/YCbCr#JPEG_conversion. + + Args: + img (ndarray): The input image. It accepts: + 1. np.uint8 type with range [0, 255]; + 2. np.float32 type with range [0, 1]. + y_only (bool): Whether to only return Y channel. Default: False. + + Returns: + ndarray: The converted YCbCr image. The output image has the same type + and range as input image. + """ + img_type = img.dtype + img = _convert_input_type_range(img) + if y_only: + out_img = np.dot(img, [24.966, 128.553, 65.481]) + 16.0 + else: + out_img = np.matmul( + img, [[24.966, 112.0, -18.214], [128.553, -74.203, -93.786], [65.481, -37.797, 112.0]]) + [16, 128, 128] + out_img = _convert_output_type_range(out_img, img_type) + return out_img + + +def ycbcr2rgb(img): + """Convert a YCbCr image to RGB image. + + This function produces the same results as Matlab's ycbcr2rgb function. + It implements the ITU-R BT.601 conversion for standard-definition + television. See more details in + https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion. + + It differs from a similar function in cv2.cvtColor: `YCrCb <-> RGB`. + In OpenCV, it implements a JPEG conversion. See more details in + https://en.wikipedia.org/wiki/YCbCr#JPEG_conversion. + + Args: + img (ndarray): The input image. It accepts: + 1. np.uint8 type with range [0, 255]; + 2. np.float32 type with range [0, 1]. + + Returns: + ndarray: The converted RGB image. The output image has the same type + and range as input image. + """ + img_type = img.dtype + img = _convert_input_type_range(img) * 255 + out_img = np.matmul(img, [[0.00456621, 0.00456621, 0.00456621], [0, -0.00153632, 0.00791071], + [0.00625893, -0.00318811, 0]]) * 255.0 + [-222.921, 135.576, -276.836] # noqa: E126 + out_img = _convert_output_type_range(out_img, img_type) + return out_img + + +def ycbcr2bgr(img): + """Convert a YCbCr image to BGR image. + + The bgr version of ycbcr2rgb. + It implements the ITU-R BT.601 conversion for standard-definition + television. See more details in + https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion. + + It differs from a similar function in cv2.cvtColor: `YCrCb <-> BGR`. + In OpenCV, it implements a JPEG conversion. See more details in + https://en.wikipedia.org/wiki/YCbCr#JPEG_conversion. + + Args: + img (ndarray): The input image. It accepts: + 1. np.uint8 type with range [0, 255]; + 2. np.float32 type with range [0, 1]. + + Returns: + ndarray: The converted BGR image. The output image has the same type + and range as input image. + """ + img_type = img.dtype + img = _convert_input_type_range(img) * 255 + out_img = np.matmul(img, [[0.00456621, 0.00456621, 0.00456621], [0.00791071, -0.00153632, 0], + [0, -0.00318811, 0.00625893]]) * 255.0 + [-276.836, 135.576, -222.921] # noqa: E126 + out_img = _convert_output_type_range(out_img, img_type) + return out_img + + +def _convert_input_type_range(img): + """Convert the type and range of the input image. + + It converts the input image to np.float32 type and range of [0, 1]. + It is mainly used for pre-processing the input image in colorspace + conversion functions such as rgb2ycbcr and ycbcr2rgb. + + Args: + img (ndarray): The input image. It accepts: + 1. np.uint8 type with range [0, 255]; + 2. np.float32 type with range [0, 1]. + + Returns: + (ndarray): The converted image with type of np.float32 and range of + [0, 1]. + """ + img_type = img.dtype + img = img.astype(np.float32) + if img_type == np.float32: + pass + elif img_type == np.uint8: + img /= 255. + else: + raise TypeError(f'The img type should be np.float32 or np.uint8, but got {img_type}') + return img + + +def _convert_output_type_range(img, dst_type): + """Convert the type and range of the image according to dst_type. + + It converts the image to desired type and range. If `dst_type` is np.uint8, + images will be converted to np.uint8 type with range [0, 255]. If + `dst_type` is np.float32, it converts the image to np.float32 type with + range [0, 1]. + It is mainly used for post-processing images in colorspace conversion + functions such as rgb2ycbcr and ycbcr2rgb. + + Args: + img (ndarray): The image to be converted with np.float32 type and + range [0, 255]. + dst_type (np.uint8 | np.float32): If dst_type is np.uint8, it + converts the image to np.uint8 type with range [0, 255]. If + dst_type is np.float32, it converts the image to np.float32 type + with range [0, 1]. + + Returns: + (ndarray): The converted image with desired type and range. + """ + if dst_type not in (np.uint8, np.float32): + raise TypeError(f'The dst_type should be np.float32 or np.uint8, but got {dst_type}') + if dst_type == np.uint8: + img = img.round() + else: + img /= 255. + return img.astype(dst_type) diff --git a/basicsr/utils/misc.py b/basicsr/utils/misc.py new file mode 100644 index 0000000000000000000000000000000000000000..728fef857d0071875c82ffcbc8c74b6fbe029e22 --- /dev/null +++ b/basicsr/utils/misc.py @@ -0,0 +1,141 @@ +import numpy as np +import os +import random +import time +import torch +from os import path as osp + +from .dist_util import master_only + + +def set_random_seed(seed): + """Set random seeds.""" + random.seed(seed) + np.random.seed(seed) + torch.manual_seed(seed) + torch.cuda.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + + +def get_time_str(): + return time.strftime('%Y%m%d_%H%M%S', time.localtime()) + + +def mkdir_and_rename(path): + """mkdirs. If path exists, rename it with timestamp and create a new one. + + Args: + path (str): Folder path. + """ + if osp.exists(path): + new_name = path + '_archived_' + get_time_str() + print(f'Path already exists. Rename it to {new_name}', flush=True) + os.rename(path, new_name) + os.makedirs(path, exist_ok=True) + + +@master_only +def make_exp_dirs(opt): + """Make dirs for experiments.""" + path_opt = opt['path'].copy() + if opt['is_train']: + mkdir_and_rename(path_opt.pop('experiments_root')) + else: + mkdir_and_rename(path_opt.pop('results_root')) + for key, path in path_opt.items(): + if ('strict_load' in key) or ('pretrain_network' in key) or ('resume' in key) or ('param_key' in key): + continue + else: + os.makedirs(path, exist_ok=True) + + +def scandir(dir_path, suffix=None, recursive=False, full_path=False): + """Scan a directory to find the interested files. + + Args: + dir_path (str): Path of the directory. + suffix (str | tuple(str), optional): File suffix that we are + interested in. Default: None. + recursive (bool, optional): If set to True, recursively scan the + directory. Default: False. + full_path (bool, optional): If set to True, include the dir_path. + Default: False. + + Returns: + A generator for all the interested files with relative paths. + """ + + if (suffix is not None) and not isinstance(suffix, (str, tuple)): + raise TypeError('"suffix" must be a string or tuple of strings') + + root = dir_path + + def _scandir(dir_path, suffix, recursive): + for entry in os.scandir(dir_path): + if not entry.name.startswith('.') and entry.is_file(): + if full_path: + return_path = entry.path + else: + return_path = osp.relpath(entry.path, root) + + if suffix is None: + yield return_path + elif return_path.endswith(suffix): + yield return_path + else: + if recursive: + yield from _scandir(entry.path, suffix=suffix, recursive=recursive) + else: + continue + + return _scandir(dir_path, suffix=suffix, recursive=recursive) + + +def check_resume(opt, resume_iter): + """Check resume states and pretrain_network paths. + + Args: + opt (dict): Options. + resume_iter (int): Resume iteration. + """ + if opt['path']['resume_state']: + # get all the networks + networks = [key for key in opt.keys() if key.startswith('network_')] + flag_pretrain = False + for network in networks: + if opt['path'].get(f'pretrain_{network}') is not None: + flag_pretrain = True + if flag_pretrain: + print('pretrain_network path will be ignored during resuming.') + # set pretrained model paths + for network in networks: + name = f'pretrain_{network}' + basename = network.replace('network_', '') + if opt['path'].get('ignore_resume_networks') is None or (network + not in opt['path']['ignore_resume_networks']): + opt['path'][name] = osp.join(opt['path']['models'], f'net_{basename}_{resume_iter}.pth') + print(f"Set {name} to {opt['path'][name]}") + + # change param_key to params in resume + param_keys = [key for key in opt['path'].keys() if key.startswith('param_key')] + for param_key in param_keys: + if opt['path'][param_key] == 'params_ema': + opt['path'][param_key] = 'params' + print(f'Set {param_key} to params') + + +def sizeof_fmt(size, suffix='B'): + """Get human readable file size. + + Args: + size (int): File size. + suffix (str): Suffix. Default: 'B'. + + Return: + str: Formatted file siz. + """ + for unit in ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z']: + if abs(size) < 1024.0: + return f'{size:3.1f} {unit}{suffix}' + size /= 1024.0 + return f'{size:3.1f} Y{suffix}' diff --git a/basicsr/utils/options.py b/basicsr/utils/options.py new file mode 100644 index 0000000000000000000000000000000000000000..cbc5bfa2c852de07179b7b67f7e4c7b886009d90 --- /dev/null +++ b/basicsr/utils/options.py @@ -0,0 +1,196 @@ +import argparse +import random +import torch +import yaml +from collections import OrderedDict +from os import path as osp + +from basicsr.utils import set_random_seed +from basicsr.utils.dist_util import get_dist_info, init_dist, master_only + + +def ordered_yaml(): + """Support OrderedDict for yaml. + + Returns: + yaml Loader and Dumper. + """ + try: + from yaml import CDumper as Dumper + from yaml import CLoader as Loader + except ImportError: + from yaml import Dumper, Loader + + _mapping_tag = yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG + + def dict_representer(dumper, data): + return dumper.represent_dict(data.items()) + + def dict_constructor(loader, node): + return OrderedDict(loader.construct_pairs(node)) + + Dumper.add_representer(OrderedDict, dict_representer) + Loader.add_constructor(_mapping_tag, dict_constructor) + return Loader, Dumper + + +def dict2str(opt, indent_level=1): + """dict to string for printing options. + + Args: + opt (dict): Option dict. + indent_level (int): Indent level. Default: 1. + + Return: + (str): Option string for printing. + """ + msg = '\n' + for k, v in opt.items(): + if isinstance(v, dict): + msg += ' ' * (indent_level * 2) + k + ':[' + msg += dict2str(v, indent_level + 1) + msg += ' ' * (indent_level * 2) + ']\n' + else: + msg += ' ' * (indent_level * 2) + k + ': ' + str(v) + '\n' + return msg + + +def _postprocess_yml_value(value): + # None + if value == '~' or value.lower() == 'none': + return None + # bool + if value.lower() == 'true': + return True + elif value.lower() == 'false': + return False + # !!float number + if value.startswith('!!float'): + return float(value.replace('!!float', '')) + # number + if value.isdigit(): + return int(value) + elif value.replace('.', '', 1).isdigit() and value.count('.') < 2: + return float(value) + # list + if value.startswith('['): + return eval(value) + # str + return value + + +def parse_options(root_path, is_train=True): + parser = argparse.ArgumentParser() + parser.add_argument('-opt', type=str, required=True, help='Path to option YAML file.') + parser.add_argument('--launcher', choices=['none', 'pytorch', 'slurm'], default='none', help='job launcher') + parser.add_argument('--auto_resume', action='store_true') + parser.add_argument('--debug', action='store_true') + parser.add_argument('--local_rank', type=int, default=0) + parser.add_argument('--local-rank', type=int, default=0) + parser.add_argument( + '--force_yml', nargs='+', default=None, help='Force to update yml files. Examples: train:ema_decay=0.999') + args = parser.parse_args() + + # parse yml to dict + with open(args.opt, mode='r') as f: + opt = yaml.load(f, Loader=ordered_yaml()[0]) + + # distributed settings + if args.launcher == 'none': + opt['dist'] = False + print('Disable distributed.', flush=True) + else: + opt['dist'] = True + if args.launcher == 'slurm' and 'dist_params' in opt: + init_dist(args.launcher, **opt['dist_params']) + else: + init_dist(args.launcher) + opt['rank'], opt['world_size'] = get_dist_info() + + # random seed + seed = opt.get('manual_seed') + if seed is None: + seed = random.randint(1, 10000) + opt['manual_seed'] = seed + set_random_seed(seed + opt['rank']) + + # force to update yml options + if args.force_yml is not None: + for entry in args.force_yml: + # now do not support creating new keys + keys, value = entry.split('=') + keys, value = keys.strip(), value.strip() + value = _postprocess_yml_value(value) + eval_str = 'opt' + for key in keys.split(':'): + eval_str += f'["{key}"]' + eval_str += '=value' + # using exec function + exec(eval_str) + + opt['auto_resume'] = args.auto_resume + opt['is_train'] = is_train + + # debug setting + if args.debug and not opt['name'].startswith('debug'): + opt['name'] = 'debug_' + opt['name'] + + if opt['num_gpu'] == 'auto': + opt['num_gpu'] = torch.cuda.device_count() + + # datasets + for phase, dataset in opt['datasets'].items(): + # for multiple datasets, e.g., val_1, val_2; test_1, test_2 + phase = phase.split('_')[0] + dataset['phase'] = phase + if 'scale' in opt: + dataset['scale'] = opt['scale'] + if dataset.get('dataroot_gt') is not None: + dataset['dataroot_gt'] = osp.expanduser(dataset['dataroot_gt']) + if dataset.get('dataroot_lq') is not None: + dataset['dataroot_lq'] = osp.expanduser(dataset['dataroot_lq']) + + # paths + for key, val in opt['path'].items(): + if (val is not None) and ('resume_state' in key or 'pretrain_network' in key): + opt['path'][key] = osp.expanduser(val) + + if is_train: + experiments_root = osp.join(root_path, 'experiments', opt['name']) + opt['path']['experiments_root'] = experiments_root + opt['path']['models'] = osp.join(experiments_root, 'models') + opt['path']['training_states'] = osp.join(experiments_root, 'training_states') + opt['path']['log'] = experiments_root + opt['path']['visualization'] = osp.join(experiments_root, 'visualization') + + # change some options for debug mode + if 'debug' in opt['name']: + if 'val' in opt: + opt['val']['val_freq'] = 8 + opt['logger']['print_freq'] = 1 + opt['logger']['save_snapshot_freq'] = 4 + opt['logger']['save_checkpoint_freq'] = 8 + else: # test + results_root = osp.join(root_path, 'results', opt['name']) + opt['path']['results_root'] = results_root + opt['path']['log'] = results_root + opt['path']['visualization'] = osp.join(results_root, 'visualization') + + return opt, args + + +@master_only +def copy_opt_file(opt_file, experiments_root): + # copy the yml file to the experiment root + import sys + import time + from shutil import copyfile + cmd = ' '.join(sys.argv) + filename = osp.join(experiments_root, osp.basename(opt_file)) + copyfile(opt_file, filename) + + with open(filename, 'r+') as f: + lines = f.readlines() + lines.insert(0, f'# GENERATE TIME: {time.asctime()}\n# CMD:\n# {cmd}\n\n') + f.seek(0) + f.writelines(lines) diff --git a/basicsr/utils/registry.py b/basicsr/utils/registry.py new file mode 100644 index 0000000000000000000000000000000000000000..655753b3b9cbd0cfe73fe93a77cf1fcc3db6d827 --- /dev/null +++ b/basicsr/utils/registry.py @@ -0,0 +1,82 @@ +# Modified from: https://github.com/facebookresearch/fvcore/blob/master/fvcore/common/registry.py # noqa: E501 + + +class Registry(): + """ + The registry that provides name -> object mapping, to support third-party + users' custom modules. + + To create a registry (e.g. a backbone registry): + + .. code-block:: python + + BACKBONE_REGISTRY = Registry('BACKBONE') + + To register an object: + + .. code-block:: python + + @BACKBONE_REGISTRY.register() + class MyBackbone(): + ... + + Or: + + .. code-block:: python + + BACKBONE_REGISTRY.register(MyBackbone) + """ + + def __init__(self, name): + """ + Args: + name (str): the name of this registry + """ + self._name = name + self._obj_map = {} + + def _do_register(self, name, obj): + assert (name not in self._obj_map), (f"An object named '{name}' was already registered " + f"in '{self._name}' registry!") + self._obj_map[name] = obj + + def register(self, obj=None): + """ + Register the given object under the the name `obj.__name__`. + Can be used as either a decorator or not. + See docstring of this class for usage. + """ + if obj is None: + # used as a decorator + def deco(func_or_class): + name = func_or_class.__name__ + self._do_register(name, func_or_class) + return func_or_class + + return deco + + # used as a function call + name = obj.__name__ + self._do_register(name, obj) + + def get(self, name): + ret = self._obj_map.get(name) + if ret is None: + raise KeyError(f"No object named '{name}' found in '{self._name}' registry!") + return ret + + def __contains__(self, name): + return name in self._obj_map + + def __iter__(self): + return iter(self._obj_map.items()) + + def keys(self): + return self._obj_map.keys() + + +DATASET_REGISTRY = Registry('dataset') +ARCH_REGISTRY = Registry('arch') +MODEL_REGISTRY = Registry('model') +LOSS_REGISTRY = Registry('loss') +METRIC_REGISTRY = Registry('metric') diff --git a/cog.yaml b/cog.yaml new file mode 100644 index 0000000000000000000000000000000000000000..6e2e93acf81e3b5baeaba4db934dd5309e6d7cfe --- /dev/null +++ b/cog.yaml @@ -0,0 +1,25 @@ +# Configuration for Cog ⚙️ +# Reference: https://github.com/replicate/cog/blob/main/docs/yaml.md + +build: + gpu: true + system_packages: + - "libgl1-mesa-glx" + - "libglib2.0-0" + - "cmake" + python_version: "3.11" + python_packages: + - torch==2.0.1 + - torchvision==0.15.2 + - lmdb==1.4.1 + - opencv_python==4.9.0.80 + - Pillow==10.1.0 + - PyYAML==6.0.1 + - scipy==1.11.4 + - timm==0.9.12 + - tqdm==4.65.0 + - scikit-image==0.22.0 + - ipython + run: + - pip install dlib +predict: "predict.py:Predictor" diff --git a/data_list/get_meta_file.py b/data_list/get_meta_file.py new file mode 100644 index 0000000000000000000000000000000000000000..efbdad0fdbe1ebe9608d04f914c94606d7d2d4f2 --- /dev/null +++ b/data_list/get_meta_file.py @@ -0,0 +1,29 @@ +from tqdm import tqdm +import argparse +import os + + +def find_and_save_images(data_path, output_name): + all_img_path = [] + + for root, dirs, files in os.walk(data_path): + for ext in ['png', 'jpg', 'jpeg', 'JPG', 'JPEG', 'PNG']: + all_img_path += [os.path.join(root, file) for file in files if file.lower().endswith(f'.{ext}')] + + with open(output_name, 'w') as f: + for path in tqdm(all_img_path): + f.write(path + '\n') + + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument('--output-name', type=str, required=True, default='dataset_name.txt', help='Path output file.') + parser.add_argument('--data-path', type=str, required=True, default='./', help='Path to dataset') + + args = parser.parse_args() + + print(f'Generating {args.output_name} from {args.data_path} ...') + + find_and_save_images(args.data_path, args.output_name) + + print('Done.') diff --git a/ddcolor_model.py b/ddcolor_model.py new file mode 100644 index 0000000000000000000000000000000000000000..a648dcb7450160b01a3a74fcdbab44f2638926ac --- /dev/null +++ b/ddcolor_model.py @@ -0,0 +1,276 @@ +import torch +import torch.nn as nn + +from basicsr.archs.ddcolor_arch_utils.unet import Hook, CustomPixelShuffle_ICNR, UnetBlockWide, NormType, custom_conv_layer +from basicsr.archs.ddcolor_arch_utils.convnext import ConvNeXt +from basicsr.archs.ddcolor_arch_utils.transformer_utils import SelfAttentionLayer, CrossAttentionLayer, FFNLayer, MLP +from basicsr.archs.ddcolor_arch_utils.position_encoding import PositionEmbeddingSine + + +class DDColor(nn.Module): + def __init__( + self, + encoder_name='convnext-l', + decoder_name='MultiScaleColorDecoder', + num_input_channels=3, + input_size=(256, 256), + nf=512, + num_output_channels=3, + last_norm='Weight', + do_normalize=False, + num_queries=256, + num_scales=3, + dec_layers=9, + ): + super().__init__() + + self.encoder = ImageEncoder(encoder_name, ['norm0', 'norm1', 'norm2', 'norm3']) + self.encoder.eval() + test_input = torch.randn(1, num_input_channels, *input_size) + self.encoder(test_input) + + self.decoder = DuelDecoder( + self.encoder.hooks, + nf=nf, + last_norm=last_norm, + num_queries=num_queries, + num_scales=num_scales, + dec_layers=dec_layers, + decoder_name=decoder_name + ) + + self.refine_net = nn.Sequential( + custom_conv_layer(num_queries + 3, num_output_channels, ks=1, use_activ=False, norm_type=NormType.Spectral) + ) + + self.do_normalize = do_normalize + self.register_buffer('mean', torch.Tensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1)) + self.register_buffer('std', torch.Tensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1)) + + def normalize(self, img): + return (img - self.mean) / self.std + + def denormalize(self, img): + return img * self.std + self.mean + + def forward(self, x): + if x.shape[1] == 3: + x = self.normalize(x) + + self.encoder(x) + out_feat = self.decoder() + coarse_input = torch.cat([out_feat, x], dim=1) + out = self.refine_net(coarse_input) + + if self.do_normalize: + out = self.denormalize(out) + return out + + +class ImageEncoder(nn.Module): + def __init__(self, encoder_name, hook_names): + super().__init__() + + assert encoder_name == 'convnext-t' or encoder_name == 'convnext-l' + if encoder_name == 'convnext-t': + self.arch = ConvNeXt(depths=[3, 3, 9, 3], dims=[96, 192, 384, 768]) + elif encoder_name == 'convnext-l': + self.arch = ConvNeXt(depths=[3, 3, 27, 3], dims=[192, 384, 768, 1536]) + else: + raise NotImplementedError + + self.encoder_name = encoder_name + self.hook_names = hook_names + self.hooks = self.setup_hooks() + + def setup_hooks(self): + hooks = [Hook(self.arch._modules[name]) for name in self.hook_names] + return hooks + + def forward(self, x): + return self.arch(x) + + +class DuelDecoder(nn.Module): + def __init__( + self, + hooks, + nf=512, + blur=True, + last_norm='Weight', + num_queries=256, + num_scales=3, + dec_layers=9, + decoder_name='MultiScaleColorDecoder', + ): + super().__init__() + self.hooks = hooks + self.nf = nf + self.blur = blur + self.last_norm = getattr(NormType, last_norm) + self.decoder_name = decoder_name + + self.layers = self.make_layers() + embed_dim = nf // 2 + self.last_shuf = CustomPixelShuffle_ICNR(embed_dim, embed_dim, blur=self.blur, norm_type=self.last_norm, scale=4) + + assert decoder_name == 'MultiScaleColorDecoder' + self.color_decoder = MultiScaleColorDecoder( + in_channels=[512, 512, 256], + num_queries=num_queries, + num_scales=num_scales, + dec_layers=dec_layers, + ) + + def make_layers(self): + decoder_layers = [] + in_c = self.hooks[-1].feature.shape[1] + out_c = self.nf + + setup_hooks = self.hooks[-2::-1] + for layer_index, hook in enumerate(setup_hooks): + feature_c = hook.feature.shape[1] + if layer_index == len(setup_hooks) - 1: + out_c = out_c // 2 + decoder_layers.append( + UnetBlockWide( + in_c, feature_c, out_c, hook, blur=self.blur, self_attention=False, norm_type=NormType.Spectral)) + in_c = out_c + + return nn.Sequential(*decoder_layers) + + def forward(self): + encode_feat = self.hooks[-1].feature + out0 = self.layers[0](encode_feat) + out1 = self.layers[1](out0) + out2 = self.layers[2](out1) + out3 = self.last_shuf(out2) + + return self.color_decoder([out0, out1, out2], out3) + + +class MultiScaleColorDecoder(nn.Module): + def __init__( + self, + in_channels, + hidden_dim=256, + num_queries=100, + nheads=8, + dim_feedforward=2048, + dec_layers=9, + pre_norm=False, + color_embed_dim=256, + enforce_input_project=True, + num_scales=3, + ): + super().__init__() + + self.hidden_dim = hidden_dim + self.num_queries = num_queries + self.num_layers = dec_layers + self.num_feature_levels = num_scales + + # Positional encoding layer + self.pe_layer = PositionEmbeddingSine(hidden_dim // 2, normalize=True) + + # Learnable query features and embeddings + self.query_feat = nn.Embedding(num_queries, hidden_dim) + self.query_embed = nn.Embedding(num_queries, hidden_dim) + + # Learnable level embeddings + self.level_embed = nn.Embedding(num_scales, hidden_dim) + + # Input projection layers + self.input_proj = nn.ModuleList( + [self._make_input_proj(in_ch, hidden_dim, enforce_input_project) for in_ch in in_channels] + ) + + # Transformer layers + self.transformer_self_attention_layers = nn.ModuleList() + self.transformer_cross_attention_layers = nn.ModuleList() + self.transformer_ffn_layers = nn.ModuleList() + + for _ in range(dec_layers): + self.transformer_self_attention_layers.append( + SelfAttentionLayer( + d_model=hidden_dim, + nhead=nheads, + dropout=0.0, + normalize_before=pre_norm, + ) + ) + self.transformer_cross_attention_layers.append( + CrossAttentionLayer( + d_model=hidden_dim, + nhead=nheads, + dropout=0.0, + normalize_before=pre_norm, + ) + ) + self.transformer_ffn_layers.append( + FFNLayer( + d_model=hidden_dim, + dim_feedforward=dim_feedforward, + dropout=0.0, + normalize_before=pre_norm, + ) + ) + + # Layer normalization for the decoder output + self.decoder_norm = nn.LayerNorm(hidden_dim) + + # Output embedding layer + self.color_embed = MLP(hidden_dim, hidden_dim, color_embed_dim, 3) + + def forward(self, x, img_features): + assert len(x) == self.num_feature_levels + + src, pos = self._get_src_and_pos(x) + + bs = src[0].shape[1] + + # Prepare query embeddings (QxNxC) + query_embed = self.query_embed.weight.unsqueeze(1).repeat(1, bs, 1) + output = self.query_feat.weight.unsqueeze(1).repeat(1, bs, 1) + + for i in range(self.num_layers): + level_index = i % self.num_feature_levels + # attention: cross-attention first + output = self.transformer_cross_attention_layers[i]( + output, src[level_index], + memory_mask=None, + memory_key_padding_mask=None, + pos=pos[level_index], query_pos=query_embed + ) + output = self.transformer_self_attention_layers[i]( + output, tgt_mask=None, + tgt_key_padding_mask=None, + query_pos=query_embed + ) + # FFN + output = self.transformer_ffn_layers[i]( + output + ) + + decoder_output = self.decoder_norm(output).transpose(0, 1) + color_embed = self.color_embed(decoder_output) + + out = torch.einsum("bqc,bchw->bqhw", color_embed, img_features) + + return out + + def _make_input_proj(self, in_ch, hidden_dim, enforce): + if in_ch != hidden_dim or enforce: + proj = nn.Conv2d(in_ch, hidden_dim, kernel_size=1) + nn.init.kaiming_uniform_(proj.weight, a=1) + if proj.bias is not None: + nn.init.constant_(proj.bias, 0) + return proj + return nn.Sequential() + + def _get_src_and_pos(self, x): + src, pos = [], [] + for i, feature in enumerate(x): + pos.append(self.pe_layer(feature).flatten(2).permute(2, 0, 1)) # flatten NxCxHxW to HWxNxC + src.append((self.input_proj[i](feature).flatten(2) + self.level_embed.weight[i][None, :, None]).permute(2, 0, 1)) + return src, pos diff --git a/export.py b/export.py new file mode 100644 index 0000000000000000000000000000000000000000..d41b2fc74216554eacf624766485ce7c9126b2d5 --- /dev/null +++ b/export.py @@ -0,0 +1,165 @@ +import types + +import argparse +import torch +import torch.nn.functional as F +import numpy as np +import onnx +import onnxsim + +from basicsr.archs.ddcolor_arch import DDColor + +from onnx import load_model, save_model, shape_inference +from onnxruntime.tools.symbolic_shape_infer import SymbolicShapeInference + + +def parse_args(): + parser = argparse.ArgumentParser(description="Export DDColor model to ONNX.") + parser.add_argument( + "--input_size", + type=int, + default=512, + help="Input image dimension.", + ) + parser.add_argument( + "--batch_size", + type=int, + default=1, + help="Input batch size.", + ) + parser.add_argument( + "--model_path", + type=str, + required=True, + help="Path to export ONNX model.", + ) + parser.add_argument( + "--model_size", + type=str, + default="tiny", + help="Path to export ONNX model.", + ) + parser.add_argument( + "--decoder_type", + type=str, + default="MultiScaleColorDecoder", + help="Path to export ONNX model.", + ) + parser.add_argument( + "--export_path", + type=str, + default="./model.onnx", + help="Path to export ONNX model.", + ) + parser.add_argument( + "--opset", + type=int, + default=12, + help="ONNX opset version.", + ) + + + return parser.parse_args() + + +def create_onnx_export(args): + input_size = args.input_size + device = torch.device('cpu') + if args.model_size == 'tiny': + encoder_name = 'convnext-t' + else: + encoder_name = 'convnext-l' + + # hardcoded in inference/colorization_pipeline.py + # decoder_type = "MultiScaleColorDecoder" + + if args.decoder_type == 'MultiScaleColorDecoder': + model = DDColor( + encoder_name=encoder_name, + decoder_name='MultiScaleColorDecoder', + input_size=[input_size, input_size], + num_output_channels=2, + last_norm='Spectral', + do_normalize=False, + num_queries=100, + num_scales=3, + dec_layers=9, + ).to(device) + elif args.decoder_type == 'SingleColorDecoder': + model = DDColor( + encoder_name=encoder_name, + decoder_name='SingleColorDecoder', + input_size=[input_size, input_size], + num_output_channels=2, + last_norm='Spectral', + do_normalize=False, + num_queries=256, + ).to(device) + else: + raise("decoder_type not implemented.") + + model.load_state_dict( + torch.load(args.model_path, map_location=device)['params'], + strict=False) + model.eval() + + channels = 3 # RGB image has 3 channels + + random_input = torch.rand((args.batch_size, channels, input_size, input_size), dtype=torch.float32) + + dynamic_axes = {} + if args.batch_size == 0: + dynamic_axes[0] = "batch" + if input_size == 0: + dynamic_axes[2] = "height" + dynamic_axes[3] = "width" + + torch.onnx.export( + model, + random_input, + args.export_path, + opset_version=args.opset, + input_names=["input"], + output_names=["output"], + dynamic_axes={ + "input": dynamic_axes, + "output": dynamic_axes + }, + ) + +def check_onnx_export(export_path): + save_model( + shape_inference.infer_shapes( + load_model(export_path), + check_type=True, + strict_mode=True, + data_prop=True + + ), + export_path + ) + + save_model( + SymbolicShapeInference.infer_shapes(load_model(export_path), + auto_merge=True, + guess_output_rank=True + ), + export_path, + ) + + model_onnx = onnx.load(export_path) # load onnx model + onnx.checker.check_model(model_onnx) # check onnx model + + model_onnx, check = onnxsim.simplify(model_onnx) + assert check, "assert check failed" + onnx.save(model_onnx, export_path) + + +if __name__ == '__main__': + args = parse_args() + + create_onnx_export(args) + print(f'ONNX file successfully created at {args.export_path}') + check_onnx_export(args.export_path) + print(f'ONNX file at {args.export_path} verifed shapes and simplified') + \ No newline at end of file diff --git a/gradio_app.py b/gradio_app.py new file mode 100644 index 0000000000000000000000000000000000000000..89f5896c8a2c2c639fc6df9d1366923d5821f18a --- /dev/null +++ b/gradio_app.py @@ -0,0 +1,120 @@ +import sys +sys.path.append('/DDColor') + +import argparse +import cv2 +import numpy as np +import os +from tqdm import tqdm +import torch +from basicsr.archs.ddcolor_arch import DDColor +import torch.nn.functional as F + +import gradio as gr +from gradio_imageslider import ImageSlider +import uuid +from PIL import Image + +model_path = 'modelscope/damo/cv_ddcolor_image-colorization/pytorch_model.pt' +input_size = 512 +model_size = 'large' + + +# Create Image Colorization Pipeline +class ImageColorizationPipeline(object): + + def __init__(self, model_path, input_size=256, model_size='large'): + + self.input_size = input_size + if torch.cuda.is_available(): + self.device = torch.device('cuda') + else: + self.device = torch.device('cpu') + + if model_size == 'tiny': + self.encoder_name = 'convnext-t' + else: + self.encoder_name = 'convnext-l' + + self.decoder_type = "MultiScaleColorDecoder" + + if self.decoder_type == 'MultiScaleColorDecoder': + self.model = DDColor( + encoder_name=self.encoder_name, + decoder_name='MultiScaleColorDecoder', + input_size=[self.input_size, self.input_size], + num_output_channels=2, + last_norm='Spectral', + do_normalize=False, + num_queries=100, + num_scales=3, + dec_layers=9, + ).to(self.device) + else: + self.model = DDColor( + encoder_name=self.encoder_name, + decoder_name='SingleColorDecoder', + input_size=[self.input_size, self.input_size], + num_output_channels=2, + last_norm='Spectral', + do_normalize=False, + num_queries=256, + ).to(self.device) + + self.model.load_state_dict( + torch.load(model_path, map_location=torch.device('cpu'))['params'], + strict=False) + self.model.eval() + + @torch.no_grad() + def process(self, img): + self.height, self.width = img.shape[:2] + img = (img / 255.0).astype(np.float32) + orig_l = cv2.cvtColor(img, cv2.COLOR_BGR2Lab)[:, :, :1] # (h, w, 1) + + # resize rgb image -> lab -> get grey -> rgb + img = cv2.resize(img, (self.input_size, self.input_size)) + img_l = cv2.cvtColor(img, cv2.COLOR_BGR2Lab)[:, :, :1] + img_gray_lab = np.concatenate((img_l, np.zeros_like(img_l), np.zeros_like(img_l)), axis=-1) + img_gray_rgb = cv2.cvtColor(img_gray_lab, cv2.COLOR_LAB2RGB) + + tensor_gray_rgb = torch.from_numpy(img_gray_rgb.transpose((2, 0, 1))).float().unsqueeze(0).to(self.device) + output_ab = self.model(tensor_gray_rgb).cpu() # (1, 2, self.height, self.width) + + # resize ab -> concat original l -> rgb + output_ab_resize = F.interpolate(output_ab, size=(self.height, self.width))[0].float().numpy().transpose(1, 2, 0) + output_lab = np.concatenate((orig_l, output_ab_resize), axis=-1) + output_bgr = cv2.cvtColor(output_lab, cv2.COLOR_LAB2BGR) + + output_img = (output_bgr * 255.0).round().astype(np.uint8) + + return output_img + + +# Initialize +colorizer = ImageColorizationPipeline(model_path=model_path, + input_size=input_size, + model_size=model_size) + + +# Create inference function for gradio app +def colorize(img): + image_out = colorizer.process(img) + # Generate a unique filename using UUID + unique_imgfilename = str(uuid.uuid4()) + '.png' + cv2.imwrite(unique_imgfilename, image_out) + return (img, unique_imgfilename) + + +# Gradio demo using the Image-Slider custom component +with gr.Blocks() as demo: + with gr.Row(): + with gr.Column(): + bw_image = gr.Image(label='Black and White Input Image') + btn = gr.Button('Convert using DDColor') + with gr.Column(): + col_image_slider = ImageSlider(position=0.5, + label='Colored Image with Slider-view') + + btn.click(colorize, bw_image, col_image_slider) +demo.launch() \ No newline at end of file diff --git a/infer.py b/infer.py new file mode 100644 index 0000000000000000000000000000000000000000..fafea34cc32e67114e563dfcdc6d82a838de7a37 --- /dev/null +++ b/infer.py @@ -0,0 +1,91 @@ +import os +import cv2 +import argparse +import torch +import numpy as np +import torch.nn.functional as F +from tqdm import tqdm + +from ddcolor_model import DDColor + + +class ImageColorizationPipeline: + def __init__(self, model_path, input_size=256, model_size='large'): + self.input_size = input_size + self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + + self.encoder_name = 'convnext-t' if model_size == 'tiny' else 'convnext-l' + self.decoder_type = 'MultiScaleColorDecoder' + + self.model = DDColor( + encoder_name=self.encoder_name, + decoder_name=self.decoder_type, + input_size=[self.input_size, self.input_size], + num_output_channels=2, + last_norm='Spectral', + do_normalize=False, + num_queries=100, + num_scales=3, + dec_layers=9, + ).to(self.device) + + # Load model weights + self.model.load_state_dict( + torch.load(model_path, map_location='cpu')['params'], + strict=False + ) + self.model.eval() + + @torch.no_grad() + def process(self, img): + height, width = img.shape[:2] + + img = (img / 255.0).astype(np.float32) + orig_l = cv2.cvtColor(img, cv2.COLOR_BGR2Lab)[:, :, :1] # (h, w, 1) + + # Resize and convert image to grayscale + img_resized = cv2.resize(img, (self.input_size, self.input_size)) + img_l = cv2.cvtColor(img_resized, cv2.COLOR_BGR2Lab)[:, :, :1] + img_gray_lab = np.concatenate((img_l, np.zeros_like(img_l), np.zeros_like(img_l)), axis=-1) + img_gray_rgb = cv2.cvtColor(img_gray_lab, cv2.COLOR_LAB2RGB) + + tensor_gray_rgb = torch.from_numpy(img_gray_rgb.transpose((2, 0, 1))).float().unsqueeze(0).to(self.device) + output_ab = self.model(tensor_gray_rgb).cpu() # (1, 2, self.input_size, self.input_size) + + # Resize output and concatenate with original L channel + output_ab_resized = F.interpolate(output_ab, size=(height, width))[0].float().numpy().transpose(1, 2, 0) + output_lab = np.concatenate((orig_l, output_ab_resized), axis=-1) + output_bgr = cv2.cvtColor(output_lab, cv2.COLOR_LAB2BGR) + + output_img = (output_bgr * 255.0).round().astype(np.uint8) + return output_img + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--model_path', type=str, default='modelscope/damo/cv_ddcolor_image-colorization/pytorch_model.pt', help='Path to the model weights') + parser.add_argument('--input', type=str, default='assets/test_images', help='Input image folder') + parser.add_argument('--output', type=str, default='results', help='Output folder') + parser.add_argument('--input_size', type=int, default=512, help='Input size for the model') + parser.add_argument('--model_size', type=str, default='large', help='DDColor model size (tiny or large)') + args = parser.parse_args() + + print(f'Output path: {args.output}') + os.makedirs(args.output, exist_ok=True) + file_list = os.listdir(args.input) + assert len(file_list) > 0, "No images found in the input directory." + + colorizer = ImageColorizationPipeline(model_path=args.model_path, input_size=args.input_size, model_size=args.model_size) + + for file_name in tqdm(file_list): + img_path = os.path.join(args.input, file_name) + img = cv2.imread(img_path) + if img is not None: + image_out = colorizer.process(img) + cv2.imwrite(os.path.join(args.output, file_name), image_out) + else: + print(f"Failed to read {img_path}") + + +if __name__ == '__main__': + main() diff --git a/infer_hf.py b/infer_hf.py new file mode 100644 index 0000000000000000000000000000000000000000..a7ea424b49bb4de6a6966059a9bc9fd85c5bede2 --- /dev/null +++ b/infer_hf.py @@ -0,0 +1,70 @@ +import os +import cv2 +import torch +import argparse +from tqdm import tqdm +from huggingface_hub import PyTorchModelHubMixin + +from ddcolor_model import DDColor +from infer import ImageColorizationPipeline + + +class DDColorHF(DDColor, PyTorchModelHubMixin): + def __init__(self, config): + super().__init__(**config) + + +class ImageColorizationPipelineHF(ImageColorizationPipeline): + def __init__(self, model, input_size): + self.input_size = input_size + if torch.cuda.is_available(): + self.device = torch.device("cuda") + else: + self.device = torch.device("cpu") + + self.model = model.to(self.device) + self.model.eval() + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--model_name", type=str, default="ddcolor_modelscope") + parser.add_argument( + "--input", + type=str, + default="figure/", + help="input test image folder or video path", + ) + parser.add_argument( + "--output", type=str, default="results", help="output folder or video path" + ) + parser.add_argument( + "--input_size", type=int, default=512, help="input size for model" + ) + + args = parser.parse_args() + + if not os.path.exists(args.model_name): + model_name = f"piddnad/{args.model_name}" + else: + model_name = args.model_name + + ddcolor_model = DDColorHF.from_pretrained(model_name) + + print(f"Output path: {args.output}") + os.makedirs(args.output, exist_ok=True) + img_list = os.listdir(args.input) + assert len(img_list) > 0 + + colorizer = ImageColorizationPipelineHF( + model=ddcolor_model, input_size=args.input_size + ) + + for name in tqdm(img_list): + img = cv2.imread(os.path.join(args.input, name)) + image_out = colorizer.process(img) + cv2.imwrite(os.path.join(args.output, name), image_out) + + +if __name__ == "__main__": + main() diff --git a/modelscope/damo/cv_ddcolor_image-colorization/.mdl b/modelscope/damo/cv_ddcolor_image-colorization/.mdl new file mode 100644 index 0000000000000000000000000000000000000000..78e3d3196e62bfb272487e62ac08f036271cad12 Binary files /dev/null and b/modelscope/damo/cv_ddcolor_image-colorization/.mdl differ diff --git a/modelscope/damo/cv_ddcolor_image-colorization/.msc b/modelscope/damo/cv_ddcolor_image-colorization/.msc new file mode 100644 index 0000000000000000000000000000000000000000..f08c1453d4fa2f25a53b8985df8c0425667ed404 Binary files /dev/null and b/modelscope/damo/cv_ddcolor_image-colorization/.msc differ diff --git a/modelscope/damo/cv_ddcolor_image-colorization/.mv b/modelscope/damo/cv_ddcolor_image-colorization/.mv new file mode 100644 index 0000000000000000000000000000000000000000..c7b2f33dd5173943769eb661710d89526ef17b9e --- /dev/null +++ b/modelscope/damo/cv_ddcolor_image-colorization/.mv @@ -0,0 +1 @@ +Revision:v1.02,CreatedAt:1678030594 \ No newline at end of file diff --git a/modelscope/damo/cv_ddcolor_image-colorization/README.md b/modelscope/damo/cv_ddcolor_image-colorization/README.md new file mode 100644 index 0000000000000000000000000000000000000000..12edf864b73f276a99f2f45d8f7089a6dec9f8f0 --- /dev/null +++ b/modelscope/damo/cv_ddcolor_image-colorization/README.md @@ -0,0 +1,114 @@ +--- +tasks: + - image-colorization +widgets: + - task: image-colorization + inputs: + - type: image + examples: + - name: 1 + inputs: + - name: image + data: git://resources/demo.jpg + - name: 2 + inputs: + - name: image + data: git://resources/demo2.jpg + - name: 3 + inputs: + - name: image + data: git://resources/demo3.jpg + inferencespec: + cpu: 4 + memory: 16000 + gpu: 1 + gpu_memory: 16000 +model-type: + - ddcolor +domain: + - cv +frameworks: + - pytorch +backbone: + - unet +metrics: + - fid + - colorfulness +customized-quickstart: False +finetune-support: False +license: Apache License 2.0 +tags: + - image colorization + - old photo restoration + - DDColor +datasets: + test: + - modelscope/image-colorization-dataset +--- + +# DDColor 图像上色模型 + +该模型为黑白图像上色模型，输入一张黑白图像，实现端到端的全图上色，返回上色处理后的彩色图像。 + +## 模型描述 + +DDColor 是最新的图像上色算法，能够对输入的黑白图像生成自然生动的彩色结果。 + +算法整体流程如下图，使用 UNet 结构的骨干网络和图像解码器分别实现图像特征提取和特征图上采样，并利用 Transformer 结构的颜色解码器完成基于视觉语义的颜色查询，最终聚合输出彩色通道预测结果。 + +![ofa-image-caption](./resources/ddcolor_arch.jpg) + +## 模型期望使用方式和适用范围 + +该模型适用于多种格式的图像输入，给定黑白图像，生成上色后的彩色图像；给定彩色图像，将自动提取灰度通道作为输入，生成重上色的图像。 + +### 如何使用 + +在 ModelScope 框架上，提供输入图片，即可以通过简单的 Pipeline 调用来使用图像上色模型。 + +#### 代码范例 + +```python +import cv2 +from modelscope.outputs import OutputKeys +from modelscope.pipelines import pipeline +from modelscope.utils.constant import Tasks + +img_colorization = pipeline(Tasks.image_colorization, + model='damo/cv_ddcolor_image-colorization') +img_path = 'https://modelscope.oss-cn-beijing.aliyuncs.com/test/images/audrey_hepburn.jpg' +result = img_colorization(img_path) +cv2.imwrite('result.png', result[OutputKeys.OUTPUT_IMG]) +``` + +### 模型局限性以及可能的偏差 + +- 本算法模型使用自然图像数据集进行训练，对于分布外场景（例如漫画等）可能产生不恰当的上色结果； +- 对于低分辨率或包含明显噪声的图像，算法可能无法得到理想的生成效果。 + +## 训练数据介绍 + +模型使用公开数据集 [ImageNet](https://www.image-net.org/) 训练，其训练集包含 128 万张自然图像。 + +## 数据评估及结果 + +本算法主要在 [ImageNet](https://www.image-net.org/) 和 [COCO-Stuff](https://github.com/nightrome/cocostuff)上测试。 + +| Val Name | FID | Colorfulness | +|:-----------------:|:----:|:------------:| +| ImageNet (val50k) | 3.92 | 38.26 | +| ImageNet (val5k) | 0.96 | 38.65 | +| COCO-Stuff | 5.18 | 38.48 | + +## 引用 + +如果你觉得这个模型对你有所帮助，请考虑引用下面的相关论文： + +``` +@article{kang2022ddcolor, + title={DDColor: Towards Photo-Realistic and Semantic-Aware Image Colorization via Dual Decoders}, + author={Kang, Xiaoyang and Yang, Tao and Ouyang, Wenqi and Ren, Peiran and Li, Lingzhi and Xie, Xuansong}, + journal={arXiv preprint arXiv:2212.11613}, + year={2022} +} +``` \ No newline at end of file diff --git a/modelscope/damo/cv_ddcolor_image-colorization/configuration.json b/modelscope/damo/cv_ddcolor_image-colorization/configuration.json new file mode 100644 index 0000000000000000000000000000000000000000..965c094e846e39f65fdf86e4b04ae017b04a58eb --- /dev/null +++ b/modelscope/damo/cv_ddcolor_image-colorization/configuration.json @@ -0,0 +1,67 @@ +{ + "framework": "pytorch", + + "task": "image-colorization", + + "pipeline": { + "type": "ddcolor-image-colorization" + }, + + "model": { + "type": "ddcolor" + }, + + "dataset": { + "name": "imagenet-val5k-image", + "dataroot_gt": "val5k/", + "filename_tmpl": "{}", + "scale": 1, + "gt_size": 256 + }, + + "train": { + "dataloader": { + "batch_size_per_gpu": 4, + "workers_per_gpu": 4, + "shuffle": true + }, + "optimizer": { + "type": "AdamW", + "lr": 1e-6, + "weight_decay": 0.01, + "betas": [0.9, 0.99] + }, + "lr_scheduler": { + "type": "CosineAnnealingLR", + "T_max": 200000, + "eta_min": 1e-7 + }, + "max_epochs": 2, + "hooks": [{ + "type": "CheckpointHook", + "interval": 1 + }, + { + "type": "TextLoggerHook", + "interval": 1 + }, + { + "type": "IterTimerHook" + }, + { + "type": "EvaluationHook", + "interval": 1 + } + ] + }, + + "evaluation": { + "dataloader": { + "batch_size_per_gpu": 8, + "workers_per_gpu": 1, + "shuffle": false + }, + "metrics": "image-colorization-metric" + } + +} \ No newline at end of file diff --git a/modelscope/damo/cv_ddcolor_image-colorization/pytorch_model.pt b/modelscope/damo/cv_ddcolor_image-colorization/pytorch_model.pt new file mode 100644 index 0000000000000000000000000000000000000000..a78f0e3dc978c07a011a7d6005c0829de352e655 --- /dev/null +++ b/modelscope/damo/cv_ddcolor_image-colorization/pytorch_model.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:17c460d7e55b32a598370621d77173be59e03c24b0823f06821db23a50c263ce +size 911950059 diff --git a/notebooks/colorization_pipeline_onnxruntime.ipynb b/notebooks/colorization_pipeline_onnxruntime.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..307882a4a7d96ba0af61e0d42d7a19d80fc83b24 --- /dev/null +++ b/notebooks/colorization_pipeline_onnxruntime.ipynb @@ -0,0 +1,276 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import os\n", + "import onnxruntime as ort\n", + "import tqdm\n", + "import cv2\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn.functional as F\n", + "model_path = '../weights/ddcolor-tiny-op12.onnx' # python export.py --model_path pretrain/ddcolor_paper_tiny.pth --export_path weights/ddcolor-tiny-op12.onnx\n", + "\n", + "#Load some example image\n", + "img = cv2.imread('../assets/test_images/Audrey Hepburn.jpg', cv2.IMREAD_COLOR)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(img)\n", + "plt.title('Input') \n", + "plt.axis('off');" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Input name: input, shape: [1, 3, 512, 512]\n", + "Output name: output, shape: [1, 2, 512, 512]\n" + ] + } + ], + "source": [ + "tmp_ort_session = ort.InferenceSession(model_path, providers=['CPUExecutionProvider'])\n", + "\n", + "# print the input,output names and shapes\n", + "for i in range(len(tmp_ort_session.get_inputs())):\n", + " print(f\"Input name: {tmp_ort_session.get_inputs()[i].name}, shape: {tmp_ort_session.get_inputs()[i].shape}\")\n", + "for i in range(len(tmp_ort_session.get_outputs())):\n", + " print(f\"Output name: {tmp_ort_session.get_outputs()[i].name}, shape: {tmp_ort_session.get_outputs()[i].shape}\")\n", + "\n", + "\n", + "providers = [\n", + " # The TensorrtExecutionProvider is the fastest.\n", + " ('TensorrtExecutionProvider', { \n", + " 'device_id': 0,\n", + " 'trt_max_workspace_size': 4 * 1024 * 1024 * 1024,\n", + " 'trt_fp16_enable': True,\n", + " 'trt_engine_cache_enable': True,\n", + " 'trt_engine_cache_path': './trt_engine_cache',\n", + " 'trt_engine_cache_prefix': 'model',\n", + " 'trt_dump_subgraphs': False,\n", + " 'trt_timing_cache_enable': True,\n", + " 'trt_timing_cache_path': './trt_engine_cache',\n", + " #'trt_builder_optimization_level': 3,\n", + " }),\n", + "\n", + " # The CUDAExecutionProvider is slower than PyTorch, \n", + " # possibly due to performance issues with large matrix multiplication \"cossim = torch.bmm(feats1, feats2.permute(0,2,1))\"\n", + " # Reducing the top_k value when exporting to ONNX can decrease the matrix size.\n", + " ('CUDAExecutionProvider', { \n", + " 'device_id': 0,\n", + " 'gpu_mem_limit': 4 * 1024 * 1024 * 1024,\n", + " }),\n", + " ('CPUExecutionProvider',{ \n", + " })\n", + "]\n", + "\n", + "ort_session = ort.InferenceSession(model_path, providers=providers)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Prepare input tensor" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "input_size = 512\n", + "batch_size = 1\n", + "height, width = img.shape[:2]\n", + "# print(self.width, self.height)\n", + "# if self.width * self.height < 100000:\n", + "# self.input_size = 256\n", + "\n", + "img = (img / 255.0).astype(np.float32)\n", + "orig_l = cv2.cvtColor(img, cv2.COLOR_BGR2Lab)[:, :, :1] # (h, w, 1)\n", + "\n", + "# resize rgb image -> lab -> get grey -> rgb\n", + "img_resize = cv2.resize(img, (input_size, input_size))\n", + "img_l = cv2.cvtColor(img_resize, cv2.COLOR_BGR2Lab)[:, :, :1]\n", + "img_gray_lab = np.concatenate((img_l, np.zeros_like(img_l), np.zeros_like(img_l)), axis=-1)\n", + "img_gray_rgb = cv2.cvtColor(img_gray_lab, cv2.COLOR_LAB2RGB)\n", + "\n", + "img_gray_rgb = img_gray_rgb.transpose((2, 0, 1)).astype(np.float32)\n", + "img_gray_rgb = np.expand_dims(img_gray_rgb, axis=0)\n", + "\n", + "# Psuedo-batch the input images\n", + "img_gray_rgb = np.concatenate([img_gray_rgb for _ in range(batch_size)], axis=0)\n", + "\n", + "inputs = {\n", + " ort_session.get_inputs()[0].name: img_gray_rgb,\n", + "}\n", + "\n", + "# output_ab = self.model(tensor_gray_rgb).cpu() # (1, 2, self.height, self.width)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Process output " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "output_ab = torch.from_numpy(ort_session.run(None, inputs)[0])\n", + "\n", + "output_ab_resize = F.interpolate(output_ab, size=(height, width))[0].float().numpy().transpose(1, 2, 0)\n", + "output_lab = np.concatenate((orig_l, output_ab_resize), axis=-1)\n", + "output_rgb = cv2.cvtColor(output_lab, cv2.COLOR_LAB2RGB)\n", + "\n", + "output_img = (output_rgb * 255.0).round().astype(np.uint8) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Output visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(1, 2, figsize=(10, 10))\n", + "\n", + "# Display input image in the first subplot\n", + "axs[0].imshow(img)\n", + "axs[0].set_title('Input') # Set title for the input image\n", + "axs[0].axis('off') # Disable axis\n", + "\n", + "# Display output image in the second subplot\n", + "axs[1].imshow(output_img)\n", + "axs[1].set_title('Output') # Set title for the output image\n", + "axs[1].axis('off') # Disable axis\n", + "\n", + "# Show the images\n", + "plt.tight_layout()\n", + "plt.show();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Benchmark" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100/100 [00:56<00:00, 1.75it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average time per batch: 0.5690 seconds\n", + "Average time per image: 0.5690 seconds\n", + "Average FPS per image: 1.7575\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "import time\n", + "\n", + "# Run the model 100 times to get an average time\n", + "times = []\n", + "for i in tqdm.tqdm(range(100)):\n", + " start = time.time()\n", + " outputs = ort_session.run(None, inputs)\n", + " times.append(time.time() - start)\n", + "\n", + "print(f\"Average time per batch: {np.mean(times):.4f} seconds\")\n", + "print(f\"Average time per image: {np.mean(times)/batch_size:.4f} seconds\")\n", + "print(f\"Average FPS per image: {batch_size/np.mean(times):.4f}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ddcolor", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.20" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/options/train/train_ddcolor.yml b/options/train/train_ddcolor.yml new file mode 100644 index 0000000000000000000000000000000000000000..bee3fcde799861761357874066128c1ac56890a2 --- /dev/null +++ b/options/train/train_ddcolor.yml @@ -0,0 +1,172 @@ +# general settings +name: train_ddcolor_l +model_type: ColorModel +scale: 1 +num_gpu: 4 +manual_seed: 0 +queue_size: 64 + +# dataset and data loader settings +datasets: + train: + name: ImageNet + type: LabDataset + dataroot_gt: / + meta_info_file: ['data_list/imagenet.txt'] + io_backend: + type: disk + + gt_size: 256 + + # augmentation config + ## flip & rotate90 + use_hflip: True + use_rot: False + + # cutmix / fmix + do_cutmix: False + cutmix_p: 0.5 + do_fmix: False + fmix_p: 0.5 + + # data loader + use_shuffle: true + num_worker_per_gpu: 8 + batch_size_per_gpu: 4 + dataset_enlarge_ratio: 1 + prefetch_mode: ~ + + # Uncomment these for validation + val: + name: ImageNet + type: LabDataset + # dataroot_gt: path_to_gt + dataroot_gt: / + meta_info_file: 'data_list/imagenet_val_5k.txt' + gt_size: 256 + io_backend: + type: disk + + # cutmix / fmix + do_cutmix: False + cutmix_p: 0.5 + do_fmix: False + fmix_p: 0.5 + +# network structures +network_g: + type: DDColor + + encoder_name: convnext-l + encoder_from_pretrain: True + + decoder_name: MultiScaleColorDecoder + num_queries: 100 + num_scales: 3 + dec_layers: 9 + + last_norm: Spectral + num_output_channels: 2 + do_normalize: False + +network_d: + type: DynamicUNetDiscriminator + nf: 64 + n_channels: 3 + + +# path +path: + pretrain_network_g: ~ + strict_load_g: true + resume_state: ~ + +# training settings +train: + color_enhance: True + color_enhance_factor: 1.2 + optim_g: + type: AdamW + lr: !!float 1e-4 + weight_decay: 0.01 + betas: [0.9, 0.99] + optim_d: + type: Adam + lr: !!float 1e-4 + weight_decay: 0 + betas: [0.9, 0.99] + + scheduler: + type: MultiStepLR + milestones: [80000, 120000, 160000, 200000, 240000, 280000, 320000, 360000] + gamma: 0.5 + + total_iter: 400000 + warmup_iter: -1 # no warm up + + # losses + pixel_opt: + type: L1Loss + loss_weight: 0.1 + reduction: mean + perceptual_opt: + type: PerceptualLoss + layer_weights: + 'conv1_1': 0.0625 + 'conv2_1': 0.125 + 'conv3_1': 0.25 + 'conv4_1': 0.5 + 'conv5_1': 1.0 + vgg_type: vgg16_bn + use_input_norm: true + range_norm: false + perceptual_weight: 5.0 + style_weight: 0 + criterion: l1 + gan_opt: + type: GANLoss + gan_type: vanilla + real_label_val: 1.0 + fake_label_val: 0.0 + loss_weight: 1.0 + colorfulness_opt: + type: ColorfulnessLoss + loss_weight: 0.5 + +# Uncomment these for validation +# validation settings +val: + val_freq: !!float 1e4 + save_img: False + pbar: True + + metrics: + fid: # metric name, can be arbitrary + type: calculate_fid + better: lower + cf: + type: calculate_cf + better: higher +# psnr: +# type: calculate_psnr +# crop_border: 4 +# test_y_channel: false + +# logging settings +logger: + print_freq: 100 + save_snapshot_freq: !!float 1e3 + save_snapshot_verbose: True + save_checkpoint_freq: !!float 1e4 + use_tb_logger: true + wandb: + project: ~ + resume_id: ~ + + +# dist training settings +dist_params: + backend: nccl + port: 29500 + +find_unused_parameters: true diff --git a/predict.py b/predict.py new file mode 100644 index 0000000000000000000000000000000000000000..6b8af6c98ea5a43eabf655934e39b9d997a09eb5 --- /dev/null +++ b/predict.py @@ -0,0 +1,117 @@ +# Prediction interface for Cog ⚙️ +# https://github.com/replicate/cog/blob/main/docs/python.md + +import cv2 +import numpy as np +from subprocess import call +import torch +import torch.nn.functional as F +from cog import BasePredictor, Input, Path + + +class Predictor(BasePredictor): + def setup(self) -> None: + """Load the model into memory to make running multiple predictions efficient""" + # download the weights to "checkpoints" + + from basicsr.archs.ddcolor_arch import DDColor + + class ImageColorizationPipeline(object): + def __init__(self, model_path, input_size=256, model_size="large"): + self.input_size = input_size + if torch.cuda.is_available(): + self.device = torch.device("cuda") + else: + self.device = torch.device("cpu") + + if model_size == "tiny": + self.encoder_name = "convnext-t" + else: + self.encoder_name = "convnext-l" + + self.decoder_type = "MultiScaleColorDecoder" + + self.model = DDColor( + encoder_name=self.encoder_name, + decoder_name="MultiScaleColorDecoder", + input_size=[self.input_size, self.input_size], + num_output_channels=2, + last_norm="Spectral", + do_normalize=False, + num_queries=100, + num_scales=3, + dec_layers=9, + ).to(self.device) + + self.model.load_state_dict( + torch.load(model_path, map_location=torch.device("cpu"))["params"], + strict=False, + ) + self.model.eval() + + @torch.no_grad() + def process(self, img): + self.height, self.width = img.shape[:2] + img = (img / 255.0).astype(np.float32) + orig_l = cv2.cvtColor(img, cv2.COLOR_BGR2Lab)[:, :, :1] # (h, w, 1) + + # resize rgb image -> lab -> get grey -> rgb + img = cv2.resize(img, (self.input_size, self.input_size)) + img_l = cv2.cvtColor(img, cv2.COLOR_BGR2Lab)[:, :, :1] + img_gray_lab = np.concatenate( + (img_l, np.zeros_like(img_l), np.zeros_like(img_l)), axis=-1 + ) + img_gray_rgb = cv2.cvtColor(img_gray_lab, cv2.COLOR_LAB2RGB) + + tensor_gray_rgb = ( + torch.from_numpy(img_gray_rgb.transpose((2, 0, 1))) + .float() + .unsqueeze(0) + .to(self.device) + ) + output_ab = self.model( + tensor_gray_rgb + ).cpu() # (1, 2, self.height, self.width) + + # resize ab -> concat original l -> rgb + output_ab_resize = ( + F.interpolate(output_ab, size=(self.height, self.width))[0] + .float() + .numpy() + .transpose(1, 2, 0) + ) + output_lab = np.concatenate((orig_l, output_ab_resize), axis=-1) + output_bgr = cv2.cvtColor(output_lab, cv2.COLOR_LAB2BGR) + + output_img = (output_bgr * 255.0).round().astype(np.uint8) + + return output_img + + self.colorizer = ImageColorizationPipeline( + model_path="checkpoints/ddcolor_modelscope.pth", + input_size=512, + model_size="large", + ) + self.colorizer_tiny = ImageColorizationPipeline( + model_path="checkpoints/ddcolor_paper_tiny.pth", + input_size=512, + model_size="tiny", + ) + + def predict( + self, + image: Path = Input(description="Grayscale input image."), + model_size: str = Input( + description="Choose the model size.", + choices=["large", "tiny"], + default="large", + ), + ) -> Path: + """Run a single prediction on the model""" + + img = cv2.imread(str(image)) + colorizer = self.colorizer_tiny if model_size == "tiny" else self.colorizer + image_out = colorizer.process(img) + out_path = "/tmp/out.png" + cv2.imwrite(out_path, image_out) + return Path(out_path) diff --git a/pretrain/put_pretrain_weights_here.txt b/pretrain/put_pretrain_weights_here.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..cf236f2ae28aed84f04ecec0124e3d7ed33c3c1e --- /dev/null +++ b/requirements.txt @@ -0,0 +1,18 @@ +dlib==19.24.2 +lmdb==1.4.1 +numpy==1.24.3 +opencv_python==4.7.0.72 +Pillow==10.1.0 +PyYAML==6.0.1 +Requests==2.31.0 +scipy +timm==0.9.2 +torch>=1.7 +torchvision +tqdm==4.65.0 +wandb==0.15.5 +scikit-image==0.22.0 +tensorboard +huggingface_hub +ipykernel +matplotlib diff --git a/scripts/inference.sh b/scripts/inference.sh new file mode 100644 index 0000000000000000000000000000000000000000..1f7f542d5f4523a6645aaf267f3bb9028efdc045 --- /dev/null +++ b/scripts/inference.sh @@ -0,0 +1,4 @@ +CUDA_VISIBLE_DEVICES=0 \ +python3 infer.py \ + --input ./assets/test_images --output ./colorize_output \ + --model_path modelscope/damo/cv_ddcolor_image-colorization/pytorch_model.pt \ No newline at end of file diff --git a/scripts/train.sh b/scripts/train.sh new file mode 100644 index 0000000000000000000000000000000000000000..d46d19f4d79028c02165bbaf9d6ebb99d2b82ac4 --- /dev/null +++ b/scripts/train.sh @@ -0,0 +1,3 @@ +CUDA_VISIBLE_DEVICES=0,1,2,3 \ +python3 -m torch.distributed.launch --nproc_per_node=4 --master_port=3721 basicsr/train.py \ + -opt options/train/train_ddcolor.yml --auto_resume --launcher pytorch diff --git a/setup.cfg b/setup.cfg new file mode 100644 index 0000000000000000000000000000000000000000..ac9d44dddc9fe811f338dd46814925030329a243 --- /dev/null +++ b/setup.cfg @@ -0,0 +1,28 @@ +[flake8] +ignore = + # line break before binary operator (W503) + W503, + # line break after binary operator (W504) + W504, +max-line-length=120 + +[yapf] +based_on_style = pep8 +column_limit = 120 +blank_line_before_nested_class_or_def = true +split_before_expression_after_opening_paren = true + +[isort] +line_length = 120 +multi_line_output = 0 +known_standard_library = pkg_resources,setuptools +known_first_party = basicsr +known_third_party = PIL,cv2,lmdb,numpy,requests,scipy,skimage,torch,torchvision,tqdm,yaml +no_lines_before = STDLIB,LOCALFOLDER +default_section = THIRDPARTY + +[codespell] +skip = .git,./docs/build,*.cfg +count = +quiet-level = 3 +ignore-words-list = gool diff --git a/setup.py b/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..9e31e945ee4286e7125753934dcf16130c9811bc --- /dev/null +++ b/setup.py @@ -0,0 +1,166 @@ +#!/usr/bin/env python + +from setuptools import find_packages, setup + +import os +import subprocess +import time +import torch +from torch.utils.cpp_extension import BuildExtension, CppExtension, CUDAExtension + +version_file = 'basicsr/version.py' + + +def readme(): + with open('README.md', encoding='utf-8') as f: + content = f.read() + return content + + +def get_git_hash(): + + def _minimal_ext_cmd(cmd): + # construct minimal environment + env = {} + for k in ['SYSTEMROOT', 'PATH', 'HOME']: + v = os.environ.get(k) + if v is not None: + env[k] = v + # LANGUAGE is used on win32 + env['LANGUAGE'] = 'C' + env['LANG'] = 'C' + env['LC_ALL'] = 'C' + out = subprocess.Popen(cmd, stdout=subprocess.PIPE, env=env).communicate()[0] + return out + + try: + out = _minimal_ext_cmd(['git', 'rev-parse', 'HEAD']) + sha = out.strip().decode('ascii') + except OSError: + sha = 'unknown' + + return sha + + +def get_hash(): + if os.path.exists('.git'): + sha = get_git_hash()[:7] + # currently ignore this + # elif os.path.exists(version_file): + # try: + # from basicsr.version import __version__ + # sha = __version__.split('+')[-1] + # except ImportError: + # raise ImportError('Unable to get git version') + else: + sha = 'unknown' + + return sha + + +def write_version_py(): + content = """# GENERATED VERSION FILE +# TIME: {} +__version__ = '{}' +__gitsha__ = '{}' +version_info = ({}) +""" + sha = get_hash() + with open('VERSION', 'r') as f: + SHORT_VERSION = f.read().strip() + VERSION_INFO = ', '.join([x if x.isdigit() else f'"{x}"' for x in SHORT_VERSION.split('.')]) + + version_file_str = content.format(time.asctime(), SHORT_VERSION, sha, VERSION_INFO) + with open(version_file, 'w') as f: + f.write(version_file_str) + + +def get_version(): + with open(version_file, 'r') as f: + exec(compile(f.read(), version_file, 'exec')) + return locals()['__version__'] + + +def make_cuda_ext(name, module, sources, sources_cuda=None): + if sources_cuda is None: + sources_cuda = [] + define_macros = [] + extra_compile_args = {'cxx': []} + + if torch.cuda.is_available() or os.getenv('FORCE_CUDA', '0') == '1': + define_macros += [('WITH_CUDA', None)] + extension = CUDAExtension + extra_compile_args['nvcc'] = [ + '-D__CUDA_NO_HALF_OPERATORS__', + '-D__CUDA_NO_HALF_CONVERSIONS__', + '-D__CUDA_NO_HALF2_OPERATORS__', + ] + sources += sources_cuda + else: + print(f'Compiling {name} without CUDA') + extension = CppExtension + + return extension( + name=f'{module}.{name}', + sources=[os.path.join(*module.split('.'), p) for p in sources], + define_macros=define_macros, + extra_compile_args=extra_compile_args) + + +def get_requirements(filename='requirements.txt'): + here = os.path.dirname(os.path.realpath(__file__)) + with open(os.path.join(here, filename), 'r') as f: + requires = [line.replace('\n', '') for line in f.readlines()] + return requires + + +if __name__ == '__main__': + cuda_ext = os.getenv('BASICSR_EXT') # whether compile cuda ext + if cuda_ext == 'True': + ext_modules = [ + make_cuda_ext( + name='deform_conv_ext', + module='basicsr.ops.dcn', + sources=['src/deform_conv_ext.cpp'], + sources_cuda=['src/deform_conv_cuda.cpp', 'src/deform_conv_cuda_kernel.cu']), + make_cuda_ext( + name='fused_act_ext', + module='basicsr.ops.fused_act', + sources=['src/fused_bias_act.cpp'], + sources_cuda=['src/fused_bias_act_kernel.cu']), + make_cuda_ext( + name='upfirdn2d_ext', + module='basicsr.ops.upfirdn2d', + sources=['src/upfirdn2d.cpp'], + sources_cuda=['src/upfirdn2d_kernel.cu']), + ] + else: + ext_modules = [] + + write_version_py() + setup( + name='basicsr', + version=get_version(), + description='Open Source Image and Video Super-Resolution Toolbox', + long_description=readme(), + long_description_content_type='text/markdown', + author='Xintao Wang', + author_email='xintao.wang@outlook.com', + keywords='computer vision, restoration, super resolution', + url='https://github.com/xinntao/BasicSR', + include_package_data=True, + packages=find_packages(exclude=('options', 'datasets', 'experiments', 'results', 'tb_logger', 'wandb')), + classifiers=[ + 'Development Status :: 4 - Beta', + 'License :: OSI Approved :: Apache Software License', + 'Operating System :: OS Independent', + 'Programming Language :: Python :: 3', + 'Programming Language :: Python :: 3.7', + 'Programming Language :: Python :: 3.8', + ], + license='Apache License 2.0', + setup_requires=['cython', 'numpy'], + install_requires=get_requirements(), + ext_modules=ext_modules, + cmdclass={'build_ext': BuildExtension}, + zip_safe=False)