Upload 126 files

.gitattributes

@@ -53,3 +53,12 @@ NAFNetModel/NAFNet/libuv/docs/src/static/architecture.png filter=lfs diff=lfs me
 NAFNetModel/NAFNet/libuv/docs/src/static/diagrams.key/preview.jpg filter=lfs diff=lfs merge=lfs -text
 NAFNetModel/outputs/output.png filter=lfs diff=lfs merge=lfs -text
 NAFNetModel/uploads/101.png filter=lfs diff=lfs merge=lfs -text
+NAFNet/demo/noisy.png filter=lfs diff=lfs merge=lfs -text
+NAFNet/demo/sr_img_l.png filter=lfs diff=lfs merge=lfs -text
+NAFNet/demo/sr_img_r.png filter=lfs diff=lfs merge=lfs -text
+NAFNet/figures/deblur.gif filter=lfs diff=lfs merge=lfs -text
+NAFNet/figures/denoise.gif filter=lfs diff=lfs merge=lfs -text
+NAFNet/figures/NAFSSR_arch.jpg filter=lfs diff=lfs merge=lfs -text
+NAFNet/figures/NAFSSR_params.jpg filter=lfs diff=lfs merge=lfs -text
+NAFNet/figures/PSNR_vs_MACs.jpg filter=lfs diff=lfs merge=lfs -text
+NAFNet/figures/StereoSR.gif filter=lfs diff=lfs merge=lfs -text

NAFNet/.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+.idea/*
+experiments
+logs/
+*results*
+*__pycache__*
+*.sh
+datasets
+basicsr.egg-info

NAFNet/LICENSE

@@ -0,0 +1,228 @@
+MIT License
+
+Copyright (c) 2022 megvii-model
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+
+BasicSR
+Copyright 2018-2020 BasicSR Authors
+
+                                 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 2018-2020 BasicSR Authors
+
+   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.

NAFNet/VERSION

@@ -0,0 +1 @@
+1.2.0

NAFNet/basicsr/data/__init__.py

@@ -0,0 +1,135 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+
+import importlib
+import numpy as np
+import random
+import torch
+import torch.utils.data
+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
+
+__all__ = ['create_dataset', 'create_dataloader']
+
+# automatically scan and import dataset modules
+# 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 create_dataset(dataset_opt):
+    """Create dataset.
+
+    Args:
+        dataset_opt (dict): Configuration for dataset. It constains:
+            name (str): Dataset name.
+            type (str): Dataset type.
+    """
+    dataset_type = dataset_opt['type']
+
+    # dynamic instantiation
+    for module in _dataset_modules:
+        dataset_cls = getattr(module, dataset_type, None)
+        if dataset_cls is not None:
+            break
+    if dataset_cls is None:
+        raise ValueError(f'Dataset {dataset_type} is not found.')
+
+    dataset = dataset_cls(dataset_opt)
+
+    logger = get_root_logger()
+    logger.info(
+        f'Dataset {dataset.__class__.__name__} - {dataset_opt["name"]} '
+        'is created.')
+    return dataset
+
+
+def create_dataloader(dataset,
+                      dataset_opt,
+                      num_gpu=1,
+                      dist=False,
+                      sampler=None,
+                      seed=None):
+    """Create 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,
+            persistent_workers=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)
+
+    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: '
+                    f'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)

NAFNet/basicsr/data/data_sampler.py

@@ -0,0 +1,56 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+
+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

NAFNet/basicsr/data/data_util.py

@@ -0,0 +1,340 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+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):
+    """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.
+
+    Returns:
+        Tensor: size (t, c, h, w), RGB, [0, 1].
+    """
+    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)
+    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, (
+        'The len of keys should be 2 with [input_key, gt_key]. '
+        f'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, (
+        'The len of keys should be 2 with [input_key, gt_key]. '
+        f'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, (
+        'The len of keys should be 2 with [input_key, gt_key]. '
+        f'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 idx in range(len(gt_paths)):
+        gt_path = gt_paths[idx]
+        basename, ext = osp.splitext(osp.basename(gt_path))
+        input_path = input_paths[idx]
+        basename_input, ext_input = osp.splitext(osp.basename(input_path))
+        input_name = f'{filename_tmpl.format(basename)}{ext_input}'
+        input_path = osp.join(input_folder, input_name)
+        assert input_name in input_paths, (f'{input_name} is not in '
+                                           f'{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

NAFNet/basicsr/data/ffhq_dataset.py

@@ -0,0 +1,71 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+from os import path as osp
+from torch.utils import data as data
+from torchvision.transforms.functional import normalize
+
+from basicsr.data.transforms import augment
+from basicsr.utils import FileClient, imfrombytes, img2tensor
+
+
+class FFHQDataset(data.Dataset):
+    """FFHQ dataset for StyleGAN.
+
+    Args:
+        opt (dict): Config for train datasets. It contains the following keys:
+            dataroot_gt (str): Data root path for gt.
+            io_backend (dict): IO backend type and other kwarg.
+            mean (list | tuple): Image mean.
+            std (list | tuple): Image std.
+            use_hflip (bool): Whether to horizontally flip.
+
+    """
+
+    def __init__(self, opt):
+        super(FFHQDataset, 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']
+        self.mean = opt['mean']
+        self.std = opt['std']
+
+        if self.io_backend_opt['type'] == 'lmdb':
+            self.io_backend_opt['db_paths'] = self.gt_folder
+            if not self.gt_folder.endswith('.lmdb'):
+                raise ValueError("'dataroot_gt' should end with '.lmdb', "
+                                 f'but received {self.gt_folder}')
+            with open(osp.join(self.gt_folder, 'meta_info.txt')) as fin:
+                self.paths = [line.split('.')[0] for line in fin]
+        else:
+            # FFHQ has 70000 images in total
+            self.paths = [
+                osp.join(self.gt_folder, f'{v:08d}.png') for v in range(70000)
+            ]
+
+    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 image
+        gt_path = self.paths[index]
+        img_bytes = self.file_client.get(gt_path)
+        img_gt = imfrombytes(img_bytes, float32=True)
+
+        # random horizontal flip
+        img_gt = augment(img_gt, hflip=self.opt['use_hflip'], rotation=False)
+        # BGR to RGB, HWC to CHW, numpy to tensor
+        img_gt = img2tensor(img_gt, bgr2rgb=True, float32=True)
+        # normalize
+        normalize(img_gt, self.mean, self.std, inplace=True)
+        return {'gt': img_gt, 'gt_path': gt_path}
+
+    def __len__(self):
+        return len(self.paths)

NAFNet/basicsr/data/meta_info/meta_info_REDS4_test_GT.txt

@@ -0,0 +1,4 @@
+000 100 (720,1280,3)
+011 100 (720,1280,3)
+015 100 (720,1280,3)
+020 100 (720,1280,3)

NAFNet/basicsr/data/meta_info/meta_info_REDS_GT.txt

@@ -0,0 +1,270 @@
+000 100 (720,1280,3)
+001 100 (720,1280,3)
+002 100 (720,1280,3)
+003 100 (720,1280,3)
+004 100 (720,1280,3)
+005 100 (720,1280,3)
+006 100 (720,1280,3)
+007 100 (720,1280,3)
+008 100 (720,1280,3)
+009 100 (720,1280,3)
+010 100 (720,1280,3)
+011 100 (720,1280,3)
+012 100 (720,1280,3)
+013 100 (720,1280,3)
+014 100 (720,1280,3)
+015 100 (720,1280,3)
+016 100 (720,1280,3)
+017 100 (720,1280,3)
+018 100 (720,1280,3)
+019 100 (720,1280,3)
+020 100 (720,1280,3)
+021 100 (720,1280,3)
+022 100 (720,1280,3)
+023 100 (720,1280,3)
+024 100 (720,1280,3)
+025 100 (720,1280,3)
+026 100 (720,1280,3)
+027 100 (720,1280,3)
+028 100 (720,1280,3)
+029 100 (720,1280,3)
+030 100 (720,1280,3)
+031 100 (720,1280,3)
+032 100 (720,1280,3)
+033 100 (720,1280,3)
+034 100 (720,1280,3)
+035 100 (720,1280,3)
+036 100 (720,1280,3)
+037 100 (720,1280,3)
+038 100 (720,1280,3)
+039 100 (720,1280,3)
+040 100 (720,1280,3)
+041 100 (720,1280,3)
+042 100 (720,1280,3)
+043 100 (720,1280,3)
+044 100 (720,1280,3)
+045 100 (720,1280,3)
+046 100 (720,1280,3)
+047 100 (720,1280,3)
+048 100 (720,1280,3)
+049 100 (720,1280,3)
+050 100 (720,1280,3)
+051 100 (720,1280,3)
+052 100 (720,1280,3)
+053 100 (720,1280,3)
+054 100 (720,1280,3)
+055 100 (720,1280,3)
+056 100 (720,1280,3)
+057 100 (720,1280,3)
+058 100 (720,1280,3)
+059 100 (720,1280,3)
+060 100 (720,1280,3)
+061 100 (720,1280,3)
+062 100 (720,1280,3)
+063 100 (720,1280,3)
+064 100 (720,1280,3)
+065 100 (720,1280,3)
+066 100 (720,1280,3)
+067 100 (720,1280,3)
+068 100 (720,1280,3)
+069 100 (720,1280,3)
+070 100 (720,1280,3)
+071 100 (720,1280,3)
+072 100 (720,1280,3)
+073 100 (720,1280,3)
+074 100 (720,1280,3)
+075 100 (720,1280,3)
+076 100 (720,1280,3)
+077 100 (720,1280,3)
+078 100 (720,1280,3)
+079 100 (720,1280,3)
+080 100 (720,1280,3)
+081 100 (720,1280,3)
+082 100 (720,1280,3)
+083 100 (720,1280,3)
+084 100 (720,1280,3)
+085 100 (720,1280,3)
+086 100 (720,1280,3)
+087 100 (720,1280,3)
+088 100 (720,1280,3)
+089 100 (720,1280,3)
+090 100 (720,1280,3)
+091 100 (720,1280,3)
+092 100 (720,1280,3)
+093 100 (720,1280,3)
+094 100 (720,1280,3)
+095 100 (720,1280,3)
+096 100 (720,1280,3)
+097 100 (720,1280,3)
+098 100 (720,1280,3)
+099 100 (720,1280,3)
+100 100 (720,1280,3)
+101 100 (720,1280,3)
+102 100 (720,1280,3)
+103 100 (720,1280,3)
+104 100 (720,1280,3)
+105 100 (720,1280,3)
+106 100 (720,1280,3)
+107 100 (720,1280,3)
+108 100 (720,1280,3)
+109 100 (720,1280,3)
+110 100 (720,1280,3)
+111 100 (720,1280,3)
+112 100 (720,1280,3)
+113 100 (720,1280,3)
+114 100 (720,1280,3)
+115 100 (720,1280,3)
+116 100 (720,1280,3)
+117 100 (720,1280,3)
+118 100 (720,1280,3)
+119 100 (720,1280,3)
+120 100 (720,1280,3)
+121 100 (720,1280,3)
+122 100 (720,1280,3)
+123 100 (720,1280,3)
+124 100 (720,1280,3)
+125 100 (720,1280,3)
+126 100 (720,1280,3)
+127 100 (720,1280,3)
+128 100 (720,1280,3)
+129 100 (720,1280,3)
+130 100 (720,1280,3)
+131 100 (720,1280,3)
+132 100 (720,1280,3)
+133 100 (720,1280,3)
+134 100 (720,1280,3)
+135 100 (720,1280,3)
+136 100 (720,1280,3)
+137 100 (720,1280,3)
+138 100 (720,1280,3)
+139 100 (720,1280,3)
+140 100 (720,1280,3)
+141 100 (720,1280,3)
+142 100 (720,1280,3)
+143 100 (720,1280,3)
+144 100 (720,1280,3)
+145 100 (720,1280,3)
+146 100 (720,1280,3)
+147 100 (720,1280,3)
+148 100 (720,1280,3)
+149 100 (720,1280,3)
+150 100 (720,1280,3)
+151 100 (720,1280,3)
+152 100 (720,1280,3)
+153 100 (720,1280,3)
+154 100 (720,1280,3)
+155 100 (720,1280,3)
+156 100 (720,1280,3)
+157 100 (720,1280,3)
+158 100 (720,1280,3)
+159 100 (720,1280,3)
+160 100 (720,1280,3)
+161 100 (720,1280,3)
+162 100 (720,1280,3)
+163 100 (720,1280,3)
+164 100 (720,1280,3)
+165 100 (720,1280,3)
+166 100 (720,1280,3)
+167 100 (720,1280,3)
+168 100 (720,1280,3)
+169 100 (720,1280,3)
+170 100 (720,1280,3)
+171 100 (720,1280,3)
+172 100 (720,1280,3)
+173 100 (720,1280,3)
+174 100 (720,1280,3)
+175 100 (720,1280,3)
+176 100 (720,1280,3)
+177 100 (720,1280,3)
+178 100 (720,1280,3)
+179 100 (720,1280,3)
+180 100 (720,1280,3)
+181 100 (720,1280,3)
+182 100 (720,1280,3)
+183 100 (720,1280,3)
+184 100 (720,1280,3)
+185 100 (720,1280,3)
+186 100 (720,1280,3)
+187 100 (720,1280,3)
+188 100 (720,1280,3)
+189 100 (720,1280,3)
+190 100 (720,1280,3)
+191 100 (720,1280,3)
+192 100 (720,1280,3)
+193 100 (720,1280,3)
+194 100 (720,1280,3)
+195 100 (720,1280,3)
+196 100 (720,1280,3)
+197 100 (720,1280,3)
+198 100 (720,1280,3)
+199 100 (720,1280,3)
+200 100 (720,1280,3)
+201 100 (720,1280,3)
+202 100 (720,1280,3)
+203 100 (720,1280,3)
+204 100 (720,1280,3)
+205 100 (720,1280,3)
+206 100 (720,1280,3)
+207 100 (720,1280,3)
+208 100 (720,1280,3)
+209 100 (720,1280,3)
+210 100 (720,1280,3)
+211 100 (720,1280,3)
+212 100 (720,1280,3)
+213 100 (720,1280,3)
+214 100 (720,1280,3)
+215 100 (720,1280,3)
+216 100 (720,1280,3)
+217 100 (720,1280,3)
+218 100 (720,1280,3)
+219 100 (720,1280,3)
+220 100 (720,1280,3)
+221 100 (720,1280,3)
+222 100 (720,1280,3)
+223 100 (720,1280,3)
+224 100 (720,1280,3)
+225 100 (720,1280,3)
+226 100 (720,1280,3)
+227 100 (720,1280,3)
+228 100 (720,1280,3)
+229 100 (720,1280,3)
+230 100 (720,1280,3)
+231 100 (720,1280,3)
+232 100 (720,1280,3)
+233 100 (720,1280,3)
+234 100 (720,1280,3)
+235 100 (720,1280,3)
+236 100 (720,1280,3)
+237 100 (720,1280,3)
+238 100 (720,1280,3)
+239 100 (720,1280,3)
+240 100 (720,1280,3)
+241 100 (720,1280,3)
+242 100 (720,1280,3)
+243 100 (720,1280,3)
+244 100 (720,1280,3)
+245 100 (720,1280,3)
+246 100 (720,1280,3)
+247 100 (720,1280,3)
+248 100 (720,1280,3)
+249 100 (720,1280,3)
+250 100 (720,1280,3)
+251 100 (720,1280,3)
+252 100 (720,1280,3)
+253 100 (720,1280,3)
+254 100 (720,1280,3)
+255 100 (720,1280,3)
+256 100 (720,1280,3)
+257 100 (720,1280,3)
+258 100 (720,1280,3)
+259 100 (720,1280,3)
+260 100 (720,1280,3)
+261 100 (720,1280,3)
+262 100 (720,1280,3)
+263 100 (720,1280,3)
+264 100 (720,1280,3)
+265 100 (720,1280,3)
+266 100 (720,1280,3)
+267 100 (720,1280,3)
+268 100 (720,1280,3)
+269 100 (720,1280,3)

NAFNet/basicsr/data/meta_info/meta_info_REDSofficial4_test_GT.txt

@@ -0,0 +1,4 @@
+240 100 (720,1280,3)
+241 100 (720,1280,3)
+246 100 (720,1280,3)
+257 100 (720,1280,3)

NAFNet/basicsr/data/meta_info/meta_info_REDSval_official_test_GT.txt

@@ -0,0 +1,30 @@
+240 100 (720,1280,3)
+241 100 (720,1280,3)
+242 100 (720,1280,3)
+243 100 (720,1280,3)
+244 100 (720,1280,3)
+245 100 (720,1280,3)
+246 100 (720,1280,3)
+247 100 (720,1280,3)
+248 100 (720,1280,3)
+249 100 (720,1280,3)
+250 100 (720,1280,3)
+251 100 (720,1280,3)
+252 100 (720,1280,3)
+253 100 (720,1280,3)
+254 100 (720,1280,3)
+255 100 (720,1280,3)
+256 100 (720,1280,3)
+257 100 (720,1280,3)
+258 100 (720,1280,3)
+259 100 (720,1280,3)
+260 100 (720,1280,3)
+261 100 (720,1280,3)
+262 100 (720,1280,3)
+263 100 (720,1280,3)
+264 100 (720,1280,3)
+265 100 (720,1280,3)
+266 100 (720,1280,3)
+267 100 (720,1280,3)
+268 100 (720,1280,3)
+269 100 (720,1280,3)

NAFNet/basicsr/data/meta_info/meta_info_Vimeo90K_test_fast_GT.txt

@@ -0,0 +1,1225 @@
+00001/0625 7 (256,448,3)
+00001/0632 7 (256,448,3)
+00001/0807 7 (256,448,3)
+00001/0832 7 (256,448,3)
+00001/0834 7 (256,448,3)
+00001/0836 7 (256,448,3)
+00002/0004 7 (256,448,3)
+00002/0112 7 (256,448,3)
+00002/0116 7 (256,448,3)
+00002/0123 7 (256,448,3)
+00002/0455 7 (256,448,3)
+00002/0602 7 (256,448,3)
+00002/0976 7 (256,448,3)
+00002/0980 7 (256,448,3)
+00002/0983 7 (256,448,3)
+00002/1000 7 (256,448,3)
+00003/0022 7 (256,448,3)
+00003/0031 7 (256,448,3)
+00003/0035 7 (256,448,3)
+00003/0041 7 (256,448,3)
+00003/0073 7 (256,448,3)
+00003/0107 7 (256,448,3)
+00003/0111 7 (256,448,3)
+00003/0114 7 (256,448,3)
+00003/0117 7 (256,448,3)
+00003/0121 7 (256,448,3)
+00003/0499 7 (256,448,3)
+00003/0501 7 (256,448,3)
+00003/0507 7 (256,448,3)
+00003/0510 7 (256,448,3)
+00003/0517 7 (256,448,3)
+00003/0522 7 (256,448,3)
+00003/0531 7 (256,448,3)
+00003/0533 7 (256,448,3)
+00003/0534 7 (256,448,3)
+00003/0682 7 (256,448,3)
+00003/0687 7 (256,448,3)
+00003/0715 7 (256,448,3)
+00003/0742 7 (256,448,3)
+00003/0751 7 (256,448,3)
+00003/0984 7 (256,448,3)
+00004/0042 7 (256,448,3)
+00004/0165 7 (256,448,3)
+00004/0321 7 (256,448,3)
+00004/0569 7 (256,448,3)
+00004/0572 7 (256,448,3)
+00004/0619 7 (256,448,3)
+00004/0776 7 (256,448,3)
+00004/0780 7 (256,448,3)
+00004/0825 7 (256,448,3)
+00004/0832 7 (256,448,3)
+00004/0853 7 (256,448,3)
+00004/0876 7 (256,448,3)
+00004/0888 7 (256,448,3)
+00005/0015 7 (256,448,3)
+00005/0021 7 (256,448,3)
+00005/0022 7 (256,448,3)
+00005/0024 7 (256,448,3)
+00005/0026 7 (256,448,3)
+00005/0394 7 (256,448,3)
+00005/0403 7 (256,448,3)
+00005/0531 7 (256,448,3)
+00005/0546 7 (256,448,3)
+00005/0554 7 (256,448,3)
+00005/0694 7 (256,448,3)
+00005/0700 7 (256,448,3)
+00005/0740 7 (256,448,3)
+00005/0826 7 (256,448,3)
+00005/0832 7 (256,448,3)
+00005/0834 7 (256,448,3)
+00005/0943 7 (256,448,3)
+00006/0184 7 (256,448,3)
+00006/0205 7 (256,448,3)
+00006/0206 7 (256,448,3)
+00006/0211 7 (256,448,3)
+00006/0271 7 (256,448,3)
+00006/0273 7 (256,448,3)
+00006/0277 7 (256,448,3)
+00006/0283 7 (256,448,3)
+00006/0287 7 (256,448,3)
+00006/0298 7 (256,448,3)
+00006/0310 7 (256,448,3)
+00006/0356 7 (256,448,3)
+00006/0357 7 (256,448,3)
+00006/0544 7 (256,448,3)
+00006/0565 7 (256,448,3)
+00006/0569 7 (256,448,3)
+00006/0573 7 (256,448,3)
+00006/0592 7 (256,448,3)
+00006/0613 7 (256,448,3)
+00006/0633 7 (256,448,3)
+00006/0637 7 (256,448,3)
+00006/0646 7 (256,448,3)
+00006/0649 7 (256,448,3)
+00006/0655 7 (256,448,3)
+00006/0658 7 (256,448,3)
+00006/0662 7 (256,448,3)
+00006/0666 7 (256,448,3)
+00006/0673 7 (256,448,3)
+00007/0248 7 (256,448,3)
+00007/0253 7 (256,448,3)
+00007/0430 7 (256,448,3)
+00007/0434 7 (256,448,3)
+00007/0436 7 (256,448,3)
+00007/0452 7 (256,448,3)
+00007/0464 7 (256,448,3)
+00007/0470 7 (256,448,3)
+00007/0472 7 (256,448,3)
+00007/0483 7 (256,448,3)
+00007/0484 7 (256,448,3)
+00007/0493 7 (256,448,3)
+00007/0508 7 (256,448,3)
+00007/0514 7 (256,448,3)
+00007/0697 7 (256,448,3)
+00007/0698 7 (256,448,3)
+00007/0744 7 (256,448,3)
+00007/0775 7 (256,448,3)
+00007/0786 7 (256,448,3)
+00007/0790 7 (256,448,3)
+00007/0800 7 (256,448,3)
+00007/0833 7 (256,448,3)
+00007/0867 7 (256,448,3)
+00007/0879 7 (256,448,3)
+00007/0899 7 (256,448,3)
+00008/0251 7 (256,448,3)
+00008/0322 7 (256,448,3)
+00008/0971 7 (256,448,3)
+00008/0976 7 (256,448,3)
+00009/0016 7 (256,448,3)
+00009/0036 7 (256,448,3)
+00009/0037 7 (256,448,3)
+00009/0609 7 (256,448,3)
+00009/0812 7 (256,448,3)
+00009/0821 7 (256,448,3)
+00009/0947 7 (256,448,3)
+00009/0952 7 (256,448,3)
+00009/0955 7 (256,448,3)
+00009/0970 7 (256,448,3)
+00010/0072 7 (256,448,3)
+00010/0074 7 (256,448,3)
+00010/0079 7 (256,448,3)
+00010/0085 7 (256,448,3)
+00010/0139 7 (256,448,3)
+00010/0140 7 (256,448,3)
+00010/0183 7 (256,448,3)
+00010/0200 7 (256,448,3)
+00010/0223 7 (256,448,3)
+00010/0305 7 (256,448,3)
+00010/0323 7 (256,448,3)
+00010/0338 7 (256,448,3)
+00010/0342 7 (256,448,3)
+00010/0350 7 (256,448,3)
+00010/0356 7 (256,448,3)
+00010/0362 7 (256,448,3)
+00010/0366 7 (256,448,3)
+00010/0375 7 (256,448,3)
+00010/0404 7 (256,448,3)
+00010/0407 7 (256,448,3)
+00010/0414 7 (256,448,3)
+00010/0418 7 (256,448,3)
+00010/0429 7 (256,448,3)
+00010/0557 7 (256,448,3)
+00010/0564 7 (256,448,3)
+00010/0733 7 (256,448,3)
+00010/0935 7 (256,448,3)
+00010/0939 7 (256,448,3)
+00010/0943 7 (256,448,3)
+00011/0242 7 (256,448,3)
+00011/0259 7 (256,448,3)
+00011/0263 7 (256,448,3)
+00011/0266 7 (256,448,3)
+00011/0278 7 (256,448,3)
+00011/0890 7 (256,448,3)
+00011/0894 7 (256,448,3)
+00011/0903 7 (256,448,3)
+00011/0906 7 (256,448,3)
+00011/0913 7 (256,448,3)
+00012/0011 7 (256,448,3)
+00012/0014 7 (256,448,3)
+00012/0126 7 (256,448,3)
+00012/0127 7 (256,448,3)
+00012/0526 7 (256,448,3)
+00012/0551 7 (256,448,3)
+00012/0896 7 (256,448,3)
+00012/0910 7 (256,448,3)
+00012/0915 7 (256,448,3)
+00013/0167 7 (256,448,3)
+00013/0794 7 (256,448,3)
+00013/0807 7 (256,448,3)
+00013/0846 7 (256,448,3)
+00013/0882 7 (256,448,3)
+00013/0889 7 (256,448,3)
+00013/0910 7 (256,448,3)
+00013/0913 7 (256,448,3)
+00013/0924 7 (256,448,3)
+00013/0931 7 (256,448,3)
+00013/0944 7 (256,448,3)
+00013/0955 7 (256,448,3)
+00013/0962 7 (256,448,3)
+00013/0969 7 (256,448,3)
+00014/0012 7 (256,448,3)
+00014/0025 7 (256,448,3)
+00014/0473 7 (256,448,3)
+00014/0499 7 (256,448,3)
+00014/0524 7 (256,448,3)
+00014/0739 7 (256,448,3)
+00014/0753 7 (256,448,3)
+00014/0771 7 (256,448,3)
+00014/0832 7 (256,448,3)
+00014/0836 7 (256,448,3)
+00014/0838 7 (256,448,3)
+00014/0839 7 (256,448,3)
+00014/0843 7 (256,448,3)
+00014/0846 7 (256,448,3)
+00014/0849 7 (256,448,3)
+00014/0859 7 (256,448,3)
+00014/0880 7 (256,448,3)
+00014/0906 7 (256,448,3)
+00015/0030 7 (256,448,3)
+00015/0067 7 (256,448,3)
+00015/0084 7 (256,448,3)
+00015/0190 7 (256,448,3)
+00015/0575 7 (256,448,3)
+00015/0784 7 (256,448,3)
+00015/0855 7 (256,448,3)
+00015/0904 7 (256,448,3)
+00015/0914 7 (256,448,3)
+00015/0936 7 (256,448,3)
+00015/0939 7 (256,448,3)
+00015/0943 7 (256,448,3)
+00015/0957 7 (256,448,3)
+00016/0131 7 (256,448,3)
+00016/0173 7 (256,448,3)
+00016/0320 7 (256,448,3)
+00016/0328 7 (256,448,3)
+00016/0334 7 (256,448,3)
+00016/0338 7 (256,448,3)
+00016/0339 7 (256,448,3)
+00016/0345 7 (256,448,3)
+00016/0365 7 (256,448,3)
+00016/0584 7 (256,448,3)
+00016/0634 7 (256,448,3)
+00017/0342 7 (256,448,3)
+00017/0346 7 (256,448,3)
+00017/0350 7 (256,448,3)
+00017/0766 7 (256,448,3)
+00017/0786 7 (256,448,3)
+00017/0911 7 (256,448,3)
+00017/0914 7 (256,448,3)
+00018/0217 7 (256,448,3)
+00018/0258 7 (256,448,3)
+00018/0307 7 (256,448,3)
+00018/0480 7 (256,448,3)
+00018/0491 7 (256,448,3)
+00018/0994 7 (256,448,3)
+00018/0995 7 (256,448,3)
+00018/0997 7 (256,448,3)
+00018/1000 7 (256,448,3)
+00019/0007 7 (256,448,3)
+00019/0016 7 (256,448,3)
+00019/0026 7 (256,448,3)
+00019/0030 7 (256,448,3)
+00019/0086 7 (256,448,3)
+00019/0089 7 (256,448,3)
+00019/0111 7 (256,448,3)
+00019/0285 7 (256,448,3)
+00019/0415 7 (256,448,3)
+00019/0434 7 (256,448,3)
+00019/0437 7 (256,448,3)
+00019/0568 7 (256,448,3)
+00019/0570 7 (256,448,3)
+00019/0591 7 (256,448,3)
+00019/0596 7 (256,448,3)
+00019/0603 7 (256,448,3)
+00019/0607 7 (256,448,3)
+00019/0637 7 (256,448,3)
+00019/0644 7 (256,448,3)
+00019/0647 7 (256,448,3)
+00019/0787 7 (256,448,3)
+00019/0993 7 (256,448,3)
+00019/0998 7 (256,448,3)
+00021/0232 7 (256,448,3)
+00021/0255 7 (256,448,3)
+00021/0646 7 (256,448,3)
+00021/0653 7 (256,448,3)
+00021/0657 7 (256,448,3)
+00021/0668 7 (256,448,3)
+00021/0672 7 (256,448,3)
+00021/0725 7 (256,448,3)
+00021/0750 7 (256,448,3)
+00021/0764 7 (256,448,3)
+00021/0821 7 (256,448,3)
+00022/0192 7 (256,448,3)
+00022/0391 7 (256,448,3)
+00022/0514 7 (256,448,3)
+00022/0567 7 (256,448,3)
+00022/0674 7 (256,448,3)
+00022/0686 7 (256,448,3)
+00022/0700 7 (256,448,3)
+00023/0020 7 (256,448,3)
+00023/0024 7 (256,448,3)
+00023/0025 7 (256,448,3)
+00023/0042 7 (256,448,3)
+00023/0050 7 (256,448,3)
+00023/0094 7 (256,448,3)
+00023/0107 7 (256,448,3)
+00023/0635 7 (256,448,3)
+00023/0698 7 (256,448,3)
+00023/0774 7 (256,448,3)
+00023/0795 7 (256,448,3)
+00023/0821 7 (256,448,3)
+00023/0839 7 (256,448,3)
+00023/0846 7 (256,448,3)
+00023/0869 7 (256,448,3)
+00023/0879 7 (256,448,3)
+00023/0887 7 (256,448,3)
+00023/0899 7 (256,448,3)
+00023/0910 7 (256,448,3)
+00023/0920 7 (256,448,3)
+00023/0929 7 (256,448,3)
+00023/0941 7 (256,448,3)
+00023/0942 7 (256,448,3)
+00023/0952 7 (256,448,3)
+00024/0066 7 (256,448,3)
+00024/0072 7 (256,448,3)
+00024/0080 7 (256,448,3)
+00024/0093 7 (256,448,3)
+00024/0107 7 (256,448,3)
+00024/0262 7 (256,448,3)
+00024/0283 7 (256,448,3)
+00024/0294 7 (256,448,3)
+00024/0296 7 (256,448,3)
+00024/0304 7 (256,448,3)
+00024/0315 7 (256,448,3)
+00024/0322 7 (256,448,3)
+00024/0648 7 (256,448,3)
+00024/0738 7 (256,448,3)
+00024/0743 7 (256,448,3)
+00025/0542 7 (256,448,3)
+00025/0769 7 (256,448,3)
+00025/0984 7 (256,448,3)
+00025/0985 7 (256,448,3)
+00025/0989 7 (256,448,3)
+00025/0991 7 (256,448,3)
+00026/0009 7 (256,448,3)
+00026/0013 7 (256,448,3)
+00026/0020 7 (256,448,3)
+00026/0021 7 (256,448,3)
+00026/0025 7 (256,448,3)
+00026/0135 7 (256,448,3)
+00026/0200 7 (256,448,3)
+00026/0297 7 (256,448,3)
+00026/0306 7 (256,448,3)
+00026/0444 7 (256,448,3)
+00026/0450 7 (256,448,3)
+00026/0453 7 (256,448,3)
+00026/0464 7 (256,448,3)
+00026/0486 7 (256,448,3)
+00026/0773 7 (256,448,3)
+00026/0785 7 (256,448,3)
+00026/0836 7 (256,448,3)
+00026/0838 7 (256,448,3)
+00026/0848 7 (256,448,3)
+00026/0885 7 (256,448,3)
+00026/0893 7 (256,448,3)
+00026/0939 7 (256,448,3)
+00026/0942 7 (256,448,3)
+00027/0092 7 (256,448,3)
+00027/0112 7 (256,448,3)
+00027/0115 7 (256,448,3)
+00027/0143 7 (256,448,3)
+00027/0175 7 (256,448,3)
+00027/0179 7 (256,448,3)
+00027/0183 7 (256,448,3)
+00027/0197 7 (256,448,3)
+00027/0199 7 (256,448,3)
+00027/0300 7 (256,448,3)
+00028/0015 7 (256,448,3)
+00028/0032 7 (256,448,3)
+00028/0048 7 (256,448,3)
+00028/0068 7 (256,448,3)
+00028/0219 7 (256,448,3)
+00028/0606 7 (256,448,3)
+00028/0626 7 (256,448,3)
+00028/0748 7 (256,448,3)
+00028/0764 7 (256,448,3)
+00028/0772 7 (256,448,3)
+00028/0780 7 (256,448,3)
+00028/0926 7 (256,448,3)
+00028/0947 7 (256,448,3)
+00028/0962 7 (256,448,3)
+00029/0085 7 (256,448,3)
+00029/0281 7 (256,448,3)
+00029/0284 7 (256,448,3)
+00029/0288 7 (256,448,3)
+00029/0294 7 (256,448,3)
+00029/0364 7 (256,448,3)
+00029/0369 7 (256,448,3)
+00029/0421 7 (256,448,3)
+00029/0425 7 (256,448,3)
+00029/0550 7 (256,448,3)
+00030/0014 7 (256,448,3)
+00030/0101 7 (256,448,3)
+00030/0143 7 (256,448,3)
+00030/0351 7 (256,448,3)
+00030/0356 7 (256,448,3)
+00030/0371 7 (256,448,3)
+00030/0484 7 (256,448,3)
+00030/0492 7 (256,448,3)
+00030/0503 7 (256,448,3)
+00030/0682 7 (256,448,3)
+00030/0696 7 (256,448,3)
+00030/0735 7 (256,448,3)
+00030/0737 7 (256,448,3)
+00030/0868 7 (256,448,3)
+00031/0161 7 (256,448,3)
+00031/0180 7 (256,448,3)
+00031/0194 7 (256,448,3)
+00031/0253 7 (256,448,3)
+00031/0293 7 (256,448,3)
+00031/0466 7 (256,448,3)
+00031/0477 7 (256,448,3)
+00031/0549 7 (256,448,3)
+00031/0600 7 (256,448,3)
+00031/0617 7 (256,448,3)
+00031/0649 7 (256,448,3)
+00032/0015 7 (256,448,3)
+00032/0020 7 (256,448,3)
+00032/0023 7 (256,448,3)
+00032/0048 7 (256,448,3)
+00032/0056 7 (256,448,3)
+00032/0872 7 (256,448,3)
+00033/0069 7 (256,448,3)
+00033/0073 7 (256,448,3)
+00033/0078 7 (256,448,3)
+00033/0079 7 (256,448,3)
+00033/0086 7 (256,448,3)
+00033/0088 7 (256,448,3)
+00033/0091 7 (256,448,3)
+00033/0096 7 (256,448,3)
+00033/0607 7 (256,448,3)
+00033/0613 7 (256,448,3)
+00033/0616 7 (256,448,3)
+00033/0619 7 (256,448,3)
+00033/0626 7 (256,448,3)
+00033/0628 7 (256,448,3)
+00033/0637 7 (256,448,3)
+00033/0686 7 (256,448,3)
+00033/0842 7 (256,448,3)
+00034/0261 7 (256,448,3)
+00034/0265 7 (256,448,3)
+00034/0269 7 (256,448,3)
+00034/0275 7 (256,448,3)
+00034/0286 7 (256,448,3)
+00034/0294 7 (256,448,3)
+00034/0431 7 (256,448,3)
+00034/0577 7 (256,448,3)
+00034/0685 7 (256,448,3)
+00034/0687 7 (256,448,3)
+00034/0703 7 (256,448,3)
+00034/0715 7 (256,448,3)
+00034/0935 7 (256,448,3)
+00034/0943 7 (256,448,3)
+00034/0963 7 (256,448,3)
+00034/0979 7 (256,448,3)
+00034/0990 7 (256,448,3)
+00035/0129 7 (256,448,3)
+00035/0153 7 (256,448,3)
+00035/0156 7 (256,448,3)
+00035/0474 7 (256,448,3)
+00035/0507 7 (256,448,3)
+00035/0532 7 (256,448,3)
+00035/0560 7 (256,448,3)
+00035/0572 7 (256,448,3)
+00035/0587 7 (256,448,3)
+00035/0588 7 (256,448,3)
+00035/0640 7 (256,448,3)
+00035/0654 7 (256,448,3)
+00035/0655 7 (256,448,3)
+00035/0737 7 (256,448,3)
+00035/0843 7 (256,448,3)
+00035/0932 7 (256,448,3)
+00035/0957 7 (256,448,3)
+00036/0029 7 (256,448,3)
+00036/0266 7 (256,448,3)
+00036/0276 7 (256,448,3)
+00036/0310 7 (256,448,3)
+00036/0314 7 (256,448,3)
+00036/0320 7 (256,448,3)
+00036/0333 7 (256,448,3)
+00036/0348 7 (256,448,3)
+00036/0357 7 (256,448,3)
+00036/0360 7 (256,448,3)
+00036/0368 7 (256,448,3)
+00036/0371 7 (256,448,3)
+00036/0378 7 (256,448,3)
+00036/0391 7 (256,448,3)
+00036/0440 7 (256,448,3)
+00036/0731 7 (256,448,3)
+00036/0733 7 (256,448,3)
+00036/0741 7 (256,448,3)
+00036/0743 7 (256,448,3)
+00036/0927 7 (256,448,3)
+00036/0931 7 (256,448,3)
+00036/0933 7 (256,448,3)
+00036/0938 7 (256,448,3)
+00036/0944 7 (256,448,3)
+00036/0946 7 (256,448,3)
+00036/0951 7 (256,448,3)
+00036/0953 7 (256,448,3)
+00036/0963 7 (256,448,3)
+00036/0964 7 (256,448,3)
+00036/0981 7 (256,448,3)
+00036/0991 7 (256,448,3)
+00037/0072 7 (256,448,3)
+00037/0079 7 (256,448,3)
+00037/0132 7 (256,448,3)
+00037/0135 7 (256,448,3)
+00037/0137 7 (256,448,3)
+00037/0141 7 (256,448,3)
+00037/0229 7 (256,448,3)
+00037/0234 7 (256,448,3)
+00037/0239 7 (256,448,3)
+00037/0242 7 (256,448,3)
+00037/0254 7 (256,448,3)
+00037/0269 7 (256,448,3)
+00037/0276 7 (256,448,3)
+00037/0279 7 (256,448,3)
+00037/0286 7 (256,448,3)
+00037/0345 7 (256,448,3)
+00037/0449 7 (256,448,3)
+00037/0450 7 (256,448,3)
+00037/0820 7 (256,448,3)
+00037/0824 7 (256,448,3)
+00037/0859 7 (256,448,3)
+00037/0899 7 (256,448,3)
+00037/0906 7 (256,448,3)
+00038/0535 7 (256,448,3)
+00038/0572 7 (256,448,3)
+00038/0675 7 (256,448,3)
+00038/0731 7 (256,448,3)
+00038/0732 7 (256,448,3)
+00038/0744 7 (256,448,3)
+00038/0755 7 (256,448,3)
+00039/0002 7 (256,448,3)
+00039/0013 7 (256,448,3)
+00039/0247 7 (256,448,3)
+00039/0489 7 (256,448,3)
+00039/0504 7 (256,448,3)
+00039/0558 7 (256,448,3)
+00039/0686 7 (256,448,3)
+00039/0727 7 (256,448,3)
+00039/0769 7 (256,448,3)
+00040/0081 7 (256,448,3)
+00040/0082 7 (256,448,3)
+00040/0402 7 (256,448,3)
+00040/0407 7 (256,448,3)
+00040/0408 7 (256,448,3)
+00040/0410 7 (256,448,3)
+00040/0411 7 (256,448,3)
+00040/0412 7 (256,448,3)
+00040/0413 7 (256,448,3)
+00040/0415 7 (256,448,3)
+00040/0421 7 (256,448,3)
+00040/0422 7 (256,448,3)
+00040/0426 7 (256,448,3)
+00040/0438 7 (256,448,3)
+00040/0439 7 (256,448,3)
+00040/0440 7 (256,448,3)
+00040/0443 7 (256,448,3)
+00040/0457 7 (256,448,3)
+00040/0459 7 (256,448,3)
+00040/0725 7 (256,448,3)
+00040/0727 7 (256,448,3)
+00040/0936 7 (256,448,3)
+00040/0959 7 (256,448,3)
+00040/0964 7 (256,448,3)
+00040/0968 7 (256,448,3)
+00040/0974 7 (256,448,3)
+00040/0978 7 (256,448,3)
+00040/0979 7 (256,448,3)
+00040/0989 7 (256,448,3)
+00040/0993 7 (256,448,3)
+00040/0994 7 (256,448,3)
+00040/0997 7 (256,448,3)
+00041/0001 7 (256,448,3)
+00041/0007 7 (256,448,3)
+00041/0019 7 (256,448,3)
+00041/0040 7 (256,448,3)
+00041/0350 7 (256,448,3)
+00041/0357 7 (256,448,3)
+00041/0393 7 (256,448,3)
+00041/0890 7 (256,448,3)
+00041/0909 7 (256,448,3)
+00041/0915 7 (256,448,3)
+00041/0933 7 (256,448,3)
+00042/0017 7 (256,448,3)
+00042/0332 7 (256,448,3)
+00042/0346 7 (256,448,3)
+00042/0350 7 (256,448,3)
+00042/0356 7 (256,448,3)
+00042/0382 7 (256,448,3)
+00042/0389 7 (256,448,3)
+00042/0539 7 (256,448,3)
+00042/0546 7 (256,448,3)
+00042/0550 7 (256,448,3)
+00042/0553 7 (256,448,3)
+00042/0555 7 (256,448,3)
+00042/0560 7 (256,448,3)
+00042/0570 7 (256,448,3)
+00043/0119 7 (256,448,3)
+00043/0122 7 (256,448,3)
+00043/0168 7 (256,448,3)
+00043/0274 7 (256,448,3)
+00043/0304 7 (256,448,3)
+00043/0731 7 (256,448,3)
+00043/0735 7 (256,448,3)
+00043/0739 7 (256,448,3)
+00043/0740 7 (256,448,3)
+00044/0212 7 (256,448,3)
+00044/0432 7 (256,448,3)
+00044/0934 7 (256,448,3)
+00044/0940 7 (256,448,3)
+00044/0987 7 (256,448,3)
+00045/0004 7 (256,448,3)
+00045/0009 7 (256,448,3)
+00045/0011 7 (256,448,3)
+00045/0019 7 (256,448,3)
+00045/0023 7 (256,448,3)
+00045/0289 7 (256,448,3)
+00045/0760 7 (256,448,3)
+00045/0779 7 (256,448,3)
+00045/0816 7 (256,448,3)
+00045/0820 7 (256,448,3)
+00046/0132 7 (256,448,3)
+00046/0350 7 (256,448,3)
+00046/0356 7 (256,448,3)
+00046/0357 7 (256,448,3)
+00046/0379 7 (256,448,3)
+00046/0410 7 (256,448,3)
+00046/0412 7 (256,448,3)
+00046/0481 7 (256,448,3)
+00046/0497 7 (256,448,3)
+00046/0510 7 (256,448,3)
+00046/0515 7 (256,448,3)
+00046/0529 7 (256,448,3)
+00046/0544 7 (256,448,3)
+00046/0545 7 (256,448,3)
+00046/0552 7 (256,448,3)
+00046/0559 7 (256,448,3)
+00046/0589 7 (256,448,3)
+00046/0642 7 (256,448,3)
+00046/0724 7 (256,448,3)
+00046/0758 7 (256,448,3)
+00046/0930 7 (256,448,3)
+00046/0953 7 (256,448,3)
+00047/0013 7 (256,448,3)
+00047/0014 7 (256,448,3)
+00047/0017 7 (256,448,3)
+00047/0076 7 (256,448,3)
+00047/0151 7 (256,448,3)
+00047/0797 7 (256,448,3)
+00048/0014 7 (256,448,3)
+00048/0021 7 (256,448,3)
+00048/0026 7 (256,448,3)
+00048/0030 7 (256,448,3)
+00048/0039 7 (256,448,3)
+00048/0045 7 (256,448,3)
+00048/0049 7 (256,448,3)
+00048/0145 7 (256,448,3)
+00048/0188 7 (256,448,3)
+00048/0302 7 (256,448,3)
+00048/0361 7 (256,448,3)
+00048/0664 7 (256,448,3)
+00048/0672 7 (256,448,3)
+00048/0681 7 (256,448,3)
+00048/0689 7 (256,448,3)
+00048/0690 7 (256,448,3)
+00048/0691 7 (256,448,3)
+00048/0711 7 (256,448,3)
+00049/0085 7 (256,448,3)
+00049/0810 7 (256,448,3)
+00049/0858 7 (256,448,3)
+00049/0865 7 (256,448,3)
+00049/0871 7 (256,448,3)
+00049/0903 7 (256,448,3)
+00049/0928 7 (256,448,3)
+00050/0092 7 (256,448,3)
+00050/0101 7 (256,448,3)
+00050/0108 7 (256,448,3)
+00050/0112 7 (256,448,3)
+00050/0120 7 (256,448,3)
+00050/0128 7 (256,448,3)
+00050/0383 7 (256,448,3)
+00050/0395 7 (256,448,3)
+00050/0405 7 (256,448,3)
+00050/0632 7 (256,448,3)
+00050/0648 7 (256,448,3)
+00050/0649 7 (256,448,3)
+00050/0659 7 (256,448,3)
+00050/0699 7 (256,448,3)
+00050/0708 7 (256,448,3)
+00050/0716 7 (256,448,3)
+00050/0758 7 (256,448,3)
+00050/0761 7 (256,448,3)
+00051/0572 7 (256,448,3)
+00052/0163 7 (256,448,3)
+00052/0242 7 (256,448,3)
+00052/0260 7 (256,448,3)
+00052/0322 7 (256,448,3)
+00052/0333 7 (256,448,3)
+00052/0806 7 (256,448,3)
+00052/0813 7 (256,448,3)
+00052/0821 7 (256,448,3)
+00052/0830 7 (256,448,3)
+00052/0914 7 (256,448,3)
+00052/0923 7 (256,448,3)
+00052/0959 7 (256,448,3)
+00053/0288 7 (256,448,3)
+00053/0290 7 (256,448,3)
+00053/0323 7 (256,448,3)
+00053/0337 7 (256,448,3)
+00053/0340 7 (256,448,3)
+00053/0437 7 (256,448,3)
+00053/0595 7 (256,448,3)
+00053/0739 7 (256,448,3)
+00053/0761 7 (256,448,3)
+00054/0014 7 (256,448,3)
+00054/0017 7 (256,448,3)
+00054/0178 7 (256,448,3)
+00054/0183 7 (256,448,3)
+00054/0196 7 (256,448,3)
+00054/0205 7 (256,448,3)
+00054/0214 7 (256,448,3)
+00054/0289 7 (256,448,3)
+00054/0453 7 (256,448,3)
+00054/0498 7 (256,448,3)
+00054/0502 7 (256,448,3)
+00054/0514 7 (256,448,3)
+00054/0773 7 (256,448,3)
+00055/0001 7 (256,448,3)
+00055/0115 7 (256,448,3)
+00055/0118 7 (256,448,3)
+00055/0171 7 (256,448,3)
+00055/0214 7 (256,448,3)
+00055/0354 7 (256,448,3)
+00055/0449 7 (256,448,3)
+00055/0473 7 (256,448,3)
+00055/0649 7 (256,448,3)
+00055/0800 7 (256,448,3)
+00055/0803 7 (256,448,3)
+00055/0990 7 (256,448,3)
+00056/0041 7 (256,448,3)
+00056/0120 7 (256,448,3)
+00056/0293 7 (256,448,3)
+00056/0357 7 (256,448,3)
+00056/0506 7 (256,448,3)
+00056/0561 7 (256,448,3)
+00056/0567 7 (256,448,3)
+00056/0575 7 (256,448,3)
+00057/0175 7 (256,448,3)
+00057/0495 7 (256,448,3)
+00057/0498 7 (256,448,3)
+00057/0506 7 (256,448,3)
+00057/0612 7 (256,448,3)
+00057/0620 7 (256,448,3)
+00057/0623 7 (256,448,3)
+00057/0635 7 (256,448,3)
+00057/0773 7 (256,448,3)
+00057/0778 7 (256,448,3)
+00057/0867 7 (256,448,3)
+00057/0976 7 (256,448,3)
+00057/0980 7 (256,448,3)
+00057/0985 7 (256,448,3)
+00057/0992 7 (256,448,3)
+00058/0009 7 (256,448,3)
+00058/0076 7 (256,448,3)
+00058/0078 7 (256,448,3)
+00058/0279 7 (256,448,3)
+00058/0283 7 (256,448,3)
+00058/0286 7 (256,448,3)
+00058/0350 7 (256,448,3)
+00058/0380 7 (256,448,3)
+00061/0132 7 (256,448,3)
+00061/0141 7 (256,448,3)
+00061/0156 7 (256,448,3)
+00061/0159 7 (256,448,3)
+00061/0168 7 (256,448,3)
+00061/0170 7 (256,448,3)
+00061/0186 7 (256,448,3)
+00061/0219 7 (256,448,3)
+00061/0227 7 (256,448,3)
+00061/0238 7 (256,448,3)
+00061/0256 7 (256,448,3)
+00061/0303 7 (256,448,3)
+00061/0312 7 (256,448,3)
+00061/0313 7 (256,448,3)
+00061/0325 7 (256,448,3)
+00061/0367 7 (256,448,3)
+00061/0369 7 (256,448,3)
+00061/0387 7 (256,448,3)
+00061/0396 7 (256,448,3)
+00061/0486 7 (256,448,3)
+00061/0895 7 (256,448,3)
+00061/0897 7 (256,448,3)
+00062/0846 7 (256,448,3)
+00063/0156 7 (256,448,3)
+00063/0184 7 (256,448,3)
+00063/0191 7 (256,448,3)
+00063/0334 7 (256,448,3)
+00063/0350 7 (256,448,3)
+00063/0499 7 (256,448,3)
+00063/0878 7 (256,448,3)
+00064/0004 7 (256,448,3)
+00064/0264 7 (256,448,3)
+00064/0735 7 (256,448,3)
+00064/0738 7 (256,448,3)
+00065/0105 7 (256,448,3)
+00065/0169 7 (256,448,3)
+00065/0305 7 (256,448,3)
+00065/0324 7 (256,448,3)
+00065/0353 7 (256,448,3)
+00065/0520 7 (256,448,3)
+00065/0533 7 (256,448,3)
+00065/0545 7 (256,448,3)
+00065/0551 7 (256,448,3)
+00065/0568 7 (256,448,3)
+00065/0603 7 (256,448,3)
+00065/0884 7 (256,448,3)
+00065/0988 7 (256,448,3)
+00066/0002 7 (256,448,3)
+00066/0011 7 (256,448,3)
+00066/0031 7 (256,448,3)
+00066/0037 7 (256,448,3)
+00066/0136 7 (256,448,3)
+00066/0137 7 (256,448,3)
+00066/0150 7 (256,448,3)
+00066/0166 7 (256,448,3)
+00066/0178 7 (256,448,3)
+00066/0357 7 (256,448,3)
+00066/0428 7 (256,448,3)
+00066/0483 7 (256,448,3)
+00066/0600 7 (256,448,3)
+00066/0863 7 (256,448,3)
+00066/0873 7 (256,448,3)
+00066/0875 7 (256,448,3)
+00066/0899 7 (256,448,3)
+00067/0020 7 (256,448,3)
+00067/0025 7 (256,448,3)
+00067/0132 7 (256,448,3)
+00067/0492 7 (256,448,3)
+00067/0726 7 (256,448,3)
+00067/0734 7 (256,448,3)
+00067/0744 7 (256,448,3)
+00067/0754 7 (256,448,3)
+00067/0779 7 (256,448,3)
+00068/0078 7 (256,448,3)
+00068/0083 7 (256,448,3)
+00068/0113 7 (256,448,3)
+00068/0117 7 (256,448,3)
+00068/0121 7 (256,448,3)
+00068/0206 7 (256,448,3)
+00068/0261 7 (256,448,3)
+00068/0321 7 (256,448,3)
+00068/0354 7 (256,448,3)
+00068/0380 7 (256,448,3)
+00068/0419 7 (256,448,3)
+00068/0547 7 (256,448,3)
+00068/0561 7 (256,448,3)
+00068/0565 7 (256,448,3)
+00068/0583 7 (256,448,3)
+00068/0599 7 (256,448,3)
+00068/0739 7 (256,448,3)
+00068/0743 7 (256,448,3)
+00068/0754 7 (256,448,3)
+00068/0812 7 (256,448,3)
+00069/0178 7 (256,448,3)
+00070/0025 7 (256,448,3)
+00070/0030 7 (256,448,3)
+00070/0036 7 (256,448,3)
+00070/0042 7 (256,448,3)
+00070/0078 7 (256,448,3)
+00070/0079 7 (256,448,3)
+00070/0362 7 (256,448,3)
+00071/0195 7 (256,448,3)
+00071/0210 7 (256,448,3)
+00071/0211 7 (256,448,3)
+00071/0221 7 (256,448,3)
+00071/0352 7 (256,448,3)
+00071/0354 7 (256,448,3)
+00071/0366 7 (256,448,3)
+00071/0454 7 (256,448,3)
+00071/0464 7 (256,448,3)
+00071/0487 7 (256,448,3)
+00071/0502 7 (256,448,3)
+00071/0561 7 (256,448,3)
+00071/0676 7 (256,448,3)
+00071/0808 7 (256,448,3)
+00071/0813 7 (256,448,3)
+00071/0836 7 (256,448,3)
+00072/0286 7 (256,448,3)
+00072/0290 7 (256,448,3)
+00072/0298 7 (256,448,3)
+00072/0302 7 (256,448,3)
+00072/0333 7 (256,448,3)
+00072/0590 7 (256,448,3)
+00072/0793 7 (256,448,3)
+00072/0803 7 (256,448,3)
+00072/0833 7 (256,448,3)
+00073/0049 7 (256,448,3)
+00073/0050 7 (256,448,3)
+00073/0388 7 (256,448,3)
+00073/0480 7 (256,448,3)
+00073/0485 7 (256,448,3)
+00073/0611 7 (256,448,3)
+00073/0616 7 (256,448,3)
+00073/0714 7 (256,448,3)
+00073/0724 7 (256,448,3)
+00073/0730 7 (256,448,3)
+00074/0034 7 (256,448,3)
+00074/0228 7 (256,448,3)
+00074/0239 7 (256,448,3)
+00074/0275 7 (256,448,3)
+00074/0527 7 (256,448,3)
+00074/0620 7 (256,448,3)
+00074/0764 7 (256,448,3)
+00074/0849 7 (256,448,3)
+00074/0893 7 (256,448,3)
+00075/0333 7 (256,448,3)
+00075/0339 7 (256,448,3)
+00075/0347 7 (256,448,3)
+00075/0399 7 (256,448,3)
+00075/0478 7 (256,448,3)
+00075/0494 7 (256,448,3)
+00075/0678 7 (256,448,3)
+00075/0688 7 (256,448,3)
+00075/0706 7 (256,448,3)
+00075/0709 7 (256,448,3)
+00075/0748 7 (256,448,3)
+00075/0769 7 (256,448,3)
+00075/0777 7 (256,448,3)
+00075/0781 7 (256,448,3)
+00076/0151 7 (256,448,3)
+00076/0159 7 (256,448,3)
+00076/0164 7 (256,448,3)
+00076/0265 7 (256,448,3)
+00076/0269 7 (256,448,3)
+00076/0433 7 (256,448,3)
+00076/0813 7 (256,448,3)
+00076/0817 7 (256,448,3)
+00076/0818 7 (256,448,3)
+00076/0827 7 (256,448,3)
+00076/0874 7 (256,448,3)
+00076/0880 7 (256,448,3)
+00076/0891 7 (256,448,3)
+00076/0894 7 (256,448,3)
+00076/0909 7 (256,448,3)
+00076/0913 7 (256,448,3)
+00076/0926 7 (256,448,3)
+00076/0962 7 (256,448,3)
+00076/0973 7 (256,448,3)
+00076/0986 7 (256,448,3)
+00077/0617 7 (256,448,3)
+00077/0623 7 (256,448,3)
+00077/0628 7 (256,448,3)
+00077/0629 7 (256,448,3)
+00077/0631 7 (256,448,3)
+00077/0639 7 (256,448,3)
+00077/0982 7 (256,448,3)
+00077/0984 7 (256,448,3)
+00077/0995 7 (256,448,3)
+00077/0998 7 (256,448,3)
+00078/0001 7 (256,448,3)
+00078/0015 7 (256,448,3)
+00078/0157 7 (256,448,3)
+00078/0161 7 (256,448,3)
+00078/0175 7 (256,448,3)
+00078/0178 7 (256,448,3)
+00078/0189 7 (256,448,3)
+00078/0192 7 (256,448,3)
+00078/0229 7 (256,448,3)
+00078/0237 7 (256,448,3)
+00078/0241 7 (256,448,3)
+00078/0249 7 (256,448,3)
+00078/0251 7 (256,448,3)
+00078/0254 7 (256,448,3)
+00078/0258 7 (256,448,3)
+00078/0311 7 (256,448,3)
+00078/0603 7 (256,448,3)
+00078/0607 7 (256,448,3)
+00078/0824 7 (256,448,3)
+00079/0045 7 (256,448,3)
+00079/0048 7 (256,448,3)
+00079/0054 7 (256,448,3)
+00080/0050 7 (256,448,3)
+00080/0488 7 (256,448,3)
+00080/0494 7 (256,448,3)
+00080/0496 7 (256,448,3)
+00080/0499 7 (256,448,3)
+00080/0502 7 (256,448,3)
+00080/0510 7 (256,448,3)
+00080/0534 7 (256,448,3)
+00080/0558 7 (256,448,3)
+00080/0571 7 (256,448,3)
+00080/0709 7 (256,448,3)
+00080/0882 7 (256,448,3)
+00081/0322 7 (256,448,3)
+00081/0428 7 (256,448,3)
+00081/0700 7 (256,448,3)
+00081/0706 7 (256,448,3)
+00081/0707 7 (256,448,3)
+00081/0937 7 (256,448,3)
+00082/0021 7 (256,448,3)
+00082/0424 7 (256,448,3)
+00082/0794 7 (256,448,3)
+00082/0807 7 (256,448,3)
+00082/0810 7 (256,448,3)
+00082/0824 7 (256,448,3)
+00083/0129 7 (256,448,3)
+00083/0131 7 (256,448,3)
+00083/0249 7 (256,448,3)
+00083/0250 7 (256,448,3)
+00083/0656 7 (256,448,3)
+00083/0812 7 (256,448,3)
+00083/0819 7 (256,448,3)
+00083/0824 7 (256,448,3)
+00083/0827 7 (256,448,3)
+00083/0841 7 (256,448,3)
+00083/0963 7 (256,448,3)
+00084/0047 7 (256,448,3)
+00084/0319 7 (256,448,3)
+00084/0334 7 (256,448,3)
+00084/0363 7 (256,448,3)
+00084/0493 7 (256,448,3)
+00084/0655 7 (256,448,3)
+00084/0752 7 (256,448,3)
+00084/0813 7 (256,448,3)
+00084/0886 7 (256,448,3)
+00084/0948 7 (256,448,3)
+00084/0976 7 (256,448,3)
+00085/0512 7 (256,448,3)
+00085/0641 7 (256,448,3)
+00085/0653 7 (256,448,3)
+00085/0655 7 (256,448,3)
+00085/0697 7 (256,448,3)
+00085/0698 7 (256,448,3)
+00085/0700 7 (256,448,3)
+00085/0703 7 (256,448,3)
+00085/0705 7 (256,448,3)
+00085/0709 7 (256,448,3)
+00085/0713 7 (256,448,3)
+00085/0739 7 (256,448,3)
+00085/0750 7 (256,448,3)
+00085/0763 7 (256,448,3)
+00085/0765 7 (256,448,3)
+00085/0769 7 (256,448,3)
+00085/0863 7 (256,448,3)
+00085/0868 7 (256,448,3)
+00085/0927 7 (256,448,3)
+00085/0936 7 (256,448,3)
+00085/0965 7 (256,448,3)
+00085/0969 7 (256,448,3)
+00085/0974 7 (256,448,3)
+00085/0981 7 (256,448,3)
+00085/0982 7 (256,448,3)
+00085/1000 7 (256,448,3)
+00086/0003 7 (256,448,3)
+00086/0009 7 (256,448,3)
+00086/0011 7 (256,448,3)
+00086/0028 7 (256,448,3)
+00086/0032 7 (256,448,3)
+00086/0034 7 (256,448,3)
+00086/0035 7 (256,448,3)
+00086/0042 7 (256,448,3)
+00086/0064 7 (256,448,3)
+00086/0066 7 (256,448,3)
+00086/0095 7 (256,448,3)
+00086/0099 7 (256,448,3)
+00086/0101 7 (256,448,3)
+00086/0104 7 (256,448,3)
+00086/0115 7 (256,448,3)
+00086/0116 7 (256,448,3)
+00086/0284 7 (256,448,3)
+00086/0291 7 (256,448,3)
+00086/0295 7 (256,448,3)
+00086/0302 7 (256,448,3)
+00086/0318 7 (256,448,3)
+00086/0666 7 (256,448,3)
+00086/0797 7 (256,448,3)
+00086/0851 7 (256,448,3)
+00086/0855 7 (256,448,3)
+00086/0874 7 (256,448,3)
+00086/0878 7 (256,448,3)
+00086/0881 7 (256,448,3)
+00086/0883 7 (256,448,3)
+00086/0896 7 (256,448,3)
+00086/0899 7 (256,448,3)
+00086/0903 7 (256,448,3)
+00086/0989 7 (256,448,3)
+00087/0008 7 (256,448,3)
+00087/0429 7 (256,448,3)
+00087/0511 7 (256,448,3)
+00088/0241 7 (256,448,3)
+00088/0319 7 (256,448,3)
+00088/0323 7 (256,448,3)
+00088/0411 7 (256,448,3)
+00088/0427 7 (256,448,3)
+00088/0452 7 (256,448,3)
+00088/0463 7 (256,448,3)
+00088/0476 7 (256,448,3)
+00088/0496 7 (256,448,3)
+00088/0559 7 (256,448,3)
+00089/0058 7 (256,448,3)
+00089/0061 7 (256,448,3)
+00089/0069 7 (256,448,3)
+00089/0077 7 (256,448,3)
+00089/0096 7 (256,448,3)
+00089/0099 7 (256,448,3)
+00089/0100 7 (256,448,3)
+00089/0211 7 (256,448,3)
+00089/0380 7 (256,448,3)
+00089/0381 7 (256,448,3)
+00089/0384 7 (256,448,3)
+00089/0390 7 (256,448,3)
+00089/0393 7 (256,448,3)
+00089/0394 7 (256,448,3)
+00089/0395 7 (256,448,3)
+00089/0406 7 (256,448,3)
+00089/0410 7 (256,448,3)
+00089/0412 7 (256,448,3)
+00089/0703 7 (256,448,3)
+00089/0729 7 (256,448,3)
+00089/0930 7 (256,448,3)
+00089/0952 7 (256,448,3)
+00090/0062 7 (256,448,3)
+00090/0101 7 (256,448,3)
+00090/0213 7 (256,448,3)
+00090/0216 7 (256,448,3)
+00090/0268 7 (256,448,3)
+00090/0406 7 (256,448,3)
+00090/0411 7 (256,448,3)
+00090/0442 7 (256,448,3)
+00090/0535 7 (256,448,3)
+00090/0542 7 (256,448,3)
+00090/0571 7 (256,448,3)
+00090/0934 7 (256,448,3)
+00090/0938 7 (256,448,3)
+00090/0947 7 (256,448,3)
+00091/0066 7 (256,448,3)
+00091/0448 7 (256,448,3)
+00091/0451 7 (256,448,3)
+00091/0454 7 (256,448,3)
+00091/0457 7 (256,448,3)
+00091/0467 7 (256,448,3)
+00091/0470 7 (256,448,3)
+00091/0477 7 (256,448,3)
+00091/0583 7 (256,448,3)
+00091/0981 7 (256,448,3)
+00091/0994 7 (256,448,3)
+00092/0112 7 (256,448,3)
+00092/0119 7 (256,448,3)
+00092/0129 7 (256,448,3)
+00092/0146 7 (256,448,3)
+00092/0149 7 (256,448,3)
+00092/0608 7 (256,448,3)
+00092/0643 7 (256,448,3)
+00092/0646 7 (256,448,3)
+00092/0766 7 (256,448,3)
+00092/0768 7 (256,448,3)
+00092/0779 7 (256,448,3)
+00093/0081 7 (256,448,3)
+00093/0085 7 (256,448,3)
+00093/0135 7 (256,448,3)
+00093/0241 7 (256,448,3)
+00093/0277 7 (256,448,3)
+00093/0283 7 (256,448,3)
+00093/0320 7 (256,448,3)
+00093/0598 7 (256,448,3)
+00094/0159 7 (256,448,3)
+00094/0253 7 (256,448,3)
+00094/0265 7 (256,448,3)
+00094/0267 7 (256,448,3)
+00094/0269 7 (256,448,3)
+00094/0281 7 (256,448,3)
+00094/0293 7 (256,448,3)
+00094/0404 7 (256,448,3)
+00094/0593 7 (256,448,3)
+00094/0612 7 (256,448,3)
+00094/0638 7 (256,448,3)
+00094/0656 7 (256,448,3)
+00094/0668 7 (256,448,3)
+00094/0786 7 (256,448,3)
+00094/0870 7 (256,448,3)
+00094/0897 7 (256,448,3)
+00094/0900 7 (256,448,3)
+00094/0944 7 (256,448,3)
+00094/0946 7 (256,448,3)
+00094/0952 7 (256,448,3)
+00094/0969 7 (256,448,3)
+00094/0973 7 (256,448,3)
+00094/0981 7 (256,448,3)
+00095/0088 7 (256,448,3)
+00095/0125 7 (256,448,3)
+00095/0130 7 (256,448,3)
+00095/0142 7 (256,448,3)
+00095/0151 7 (256,448,3)
+00095/0180 7 (256,448,3)
+00095/0192 7 (256,448,3)
+00095/0194 7 (256,448,3)
+00095/0195 7 (256,448,3)
+00095/0204 7 (256,448,3)
+00095/0245 7 (256,448,3)
+00095/0315 7 (256,448,3)
+00095/0321 7 (256,448,3)
+00095/0324 7 (256,448,3)
+00095/0327 7 (256,448,3)
+00095/0730 7 (256,448,3)
+00095/0731 7 (256,448,3)
+00095/0741 7 (256,448,3)
+00095/0948 7 (256,448,3)
+00096/0407 7 (256,448,3)
+00096/0420 7 (256,448,3)
+00096/0435 7 (256,448,3)
+00096/0682 7 (256,448,3)
+00096/0865 7 (256,448,3)

NAFNet/basicsr/data/meta_info/meta_info_Vimeo90K_test_slow_GT.txt

@@ -0,0 +1,1613 @@
+00001/0266 7 (256,448,3)
+00001/0268 7 (256,448,3)
+00001/0275 7 (256,448,3)
+00001/0278 7 (256,448,3)
+00001/0287 7 (256,448,3)
+00001/0291 7 (256,448,3)
+00001/0627 7 (256,448,3)
+00001/0636 7 (256,448,3)
+00001/0804 7 (256,448,3)
+00001/0837 7 (256,448,3)
+00001/0849 7 (256,448,3)
+00001/0851 7 (256,448,3)
+00001/0852 7 (256,448,3)
+00001/0986 7 (256,448,3)
+00001/0991 7 (256,448,3)
+00002/0007 7 (256,448,3)
+00002/0008 7 (256,448,3)
+00002/0016 7 (256,448,3)
+00002/0036 7 (256,448,3)
+00002/0091 7 (256,448,3)
+00002/0093 7 (256,448,3)
+00002/0209 7 (256,448,3)
+00002/0235 7 (256,448,3)
+00002/0236 7 (256,448,3)
+00002/0241 7 (256,448,3)
+00002/0466 7 (256,448,3)
+00002/0504 7 (256,448,3)
+00002/0960 7 (256,448,3)
+00002/0961 7 (256,448,3)
+00002/0964 7 (256,448,3)
+00003/0007 7 (256,448,3)
+00003/0069 7 (256,448,3)
+00003/0345 7 (256,448,3)
+00003/0347 7 (256,448,3)
+00003/0372 7 (256,448,3)
+00003/0525 7 (256,448,3)
+00003/0652 7 (256,448,3)
+00003/0667 7 (256,448,3)
+00003/0669 7 (256,448,3)
+00003/0706 7 (256,448,3)
+00003/0713 7 (256,448,3)
+00003/0721 7 (256,448,3)
+00003/0747 7 (256,448,3)
+00003/0829 7 (256,448,3)
+00003/0916 7 (256,448,3)
+00003/0918 7 (256,448,3)
+00003/0924 7 (256,448,3)
+00003/0926 7 (256,448,3)
+00003/0927 7 (256,448,3)
+00004/0288 7 (256,448,3)
+00004/0303 7 (256,448,3)
+00004/0307 7 (256,448,3)
+00004/0628 7 (256,448,3)
+00004/0713 7 (256,448,3)
+00004/0715 7 (256,448,3)
+00004/0719 7 (256,448,3)
+00004/0727 7 (256,448,3)
+00004/0821 7 (256,448,3)
+00005/0006 7 (256,448,3)
+00005/0007 7 (256,448,3)
+00005/0012 7 (256,448,3)
+00005/0013 7 (256,448,3)
+00005/0040 7 (256,448,3)
+00005/0055 7 (256,448,3)
+00005/0119 7 (256,448,3)
+00005/0130 7 (256,448,3)
+00005/0185 7 (256,448,3)
+00005/0198 7 (256,448,3)
+00005/0270 7 (256,448,3)
+00005/0541 7 (256,448,3)
+00005/0560 7 (256,448,3)
+00005/0660 7 (256,448,3)
+00005/0682 7 (256,448,3)
+00005/0683 7 (256,448,3)
+00005/0688 7 (256,448,3)
+00005/0706 7 (256,448,3)
+00005/0728 7 (256,448,3)
+00005/0732 7 (256,448,3)
+00005/0739 7 (256,448,3)
+00005/0804 7 (256,448,3)
+00005/0805 7 (256,448,3)
+00005/0827 7 (256,448,3)
+00005/0828 7 (256,448,3)
+00005/0857 7 (256,448,3)
+00005/0861 7 (256,448,3)
+00005/0862 7 (256,448,3)
+00005/0868 7 (256,448,3)
+00005/0872 7 (256,448,3)
+00005/0933 7 (256,448,3)
+00005/0958 7 (256,448,3)
+00005/0960 7 (256,448,3)
+00006/0087 7 (256,448,3)
+00006/0090 7 (256,448,3)
+00006/0351 7 (256,448,3)
+00006/0353 7 (256,448,3)
+00006/0558 7 (256,448,3)
+00006/0588 7 (256,448,3)
+00006/0619 7 (256,448,3)
+00006/0621 7 (256,448,3)
+00006/0748 7 (256,448,3)
+00006/0796 7 (256,448,3)
+00006/0805 7 (256,448,3)
+00006/0807 7 (256,448,3)
+00007/0236 7 (256,448,3)
+00007/0240 7 (256,448,3)
+00007/0243 7 (256,448,3)
+00007/0246 7 (256,448,3)
+00007/0247 7 (256,448,3)
+00007/0252 7 (256,448,3)
+00007/0322 7 (256,448,3)
+00007/0458 7 (256,448,3)
+00007/0492 7 (256,448,3)
+00007/0658 7 (256,448,3)
+00007/0717 7 (256,448,3)
+00007/0722 7 (256,448,3)
+00007/0725 7 (256,448,3)
+00007/0740 7 (256,448,3)
+00007/0748 7 (256,448,3)
+00007/0749 7 (256,448,3)
+00007/0759 7 (256,448,3)
+00007/0772 7 (256,448,3)
+00007/0783 7 (256,448,3)
+00007/0787 7 (256,448,3)
+00007/0883 7 (256,448,3)
+00008/0033 7 (256,448,3)
+00008/0035 7 (256,448,3)
+00008/0091 7 (256,448,3)
+00008/0154 7 (256,448,3)
+00008/0966 7 (256,448,3)
+00008/0987 7 (256,448,3)
+00009/0108 7 (256,448,3)
+00009/0607 7 (256,448,3)
+00009/0668 7 (256,448,3)
+00009/0683 7 (256,448,3)
+00009/0941 7 (256,448,3)
+00009/0949 7 (256,448,3)
+00009/0962 7 (256,448,3)
+00009/0972 7 (256,448,3)
+00009/0974 7 (256,448,3)
+00010/0014 7 (256,448,3)
+00010/0018 7 (256,448,3)
+00010/0043 7 (256,448,3)
+00010/0099 7 (256,448,3)
+00010/0252 7 (256,448,3)
+00010/0296 7 (256,448,3)
+00010/0413 7 (256,448,3)
+00010/0422 7 (256,448,3)
+00010/0516 7 (256,448,3)
+00010/0525 7 (256,448,3)
+00010/0556 7 (256,448,3)
+00010/0701 7 (256,448,3)
+00010/0740 7 (256,448,3)
+00010/0772 7 (256,448,3)
+00010/0831 7 (256,448,3)
+00010/0925 7 (256,448,3)
+00011/0013 7 (256,448,3)
+00011/0016 7 (256,448,3)
+00011/0017 7 (256,448,3)
+00011/0249 7 (256,448,3)
+00011/0826 7 (256,448,3)
+00011/0827 7 (256,448,3)
+00011/0831 7 (256,448,3)
+00011/0833 7 (256,448,3)
+00011/0835 7 (256,448,3)
+00011/0998 7 (256,448,3)
+00012/0023 7 (256,448,3)
+00012/0024 7 (256,448,3)
+00012/0027 7 (256,448,3)
+00012/0037 7 (256,448,3)
+00012/0444 7 (256,448,3)
+00012/0445 7 (256,448,3)
+00012/0451 7 (256,448,3)
+00012/0461 7 (256,448,3)
+00012/0521 7 (256,448,3)
+00012/0758 7 (256,448,3)
+00012/0760 7 (256,448,3)
+00012/0771 7 (256,448,3)
+00012/0903 7 (256,448,3)
+00012/0909 7 (256,448,3)
+00013/0581 7 (256,448,3)
+00013/0786 7 (256,448,3)
+00013/0789 7 (256,448,3)
+00013/0791 7 (256,448,3)
+00013/0798 7 (256,448,3)
+00013/0802 7 (256,448,3)
+00013/0820 7 (256,448,3)
+00013/0850 7 (256,448,3)
+00013/0854 7 (256,448,3)
+00013/0894 7 (256,448,3)
+00013/0919 7 (256,448,3)
+00013/0999 7 (256,448,3)
+00014/0001 7 (256,448,3)
+00014/0014 7 (256,448,3)
+00014/0018 7 (256,448,3)
+00014/0244 7 (256,448,3)
+00014/0475 7 (256,448,3)
+00014/0483 7 (256,448,3)
+00014/0680 7 (256,448,3)
+00014/0700 7 (256,448,3)
+00014/0701 7 (256,448,3)
+00014/0706 7 (256,448,3)
+00014/0712 7 (256,448,3)
+00014/0713 7 (256,448,3)
+00014/0717 7 (256,448,3)
+00014/0719 7 (256,448,3)
+00014/0728 7 (256,448,3)
+00014/0734 7 (256,448,3)
+00014/0736 7 (256,448,3)
+00014/0738 7 (256,448,3)
+00014/0742 7 (256,448,3)
+00014/0745 7 (256,448,3)
+00014/0746 7 (256,448,3)
+00014/0750 7 (256,448,3)
+00014/0769 7 (256,448,3)
+00014/0774 7 (256,448,3)
+00014/0781 7 (256,448,3)
+00014/0782 7 (256,448,3)
+00014/0852 7 (256,448,3)
+00014/0853 7 (256,448,3)
+00014/0855 7 (256,448,3)
+00014/0867 7 (256,448,3)
+00014/0876 7 (256,448,3)
+00014/0881 7 (256,448,3)
+00014/0890 7 (256,448,3)
+00014/0914 7 (256,448,3)
+00015/0033 7 (256,448,3)
+00015/0113 7 (256,448,3)
+00015/0125 7 (256,448,3)
+00015/0185 7 (256,448,3)
+00015/0194 7 (256,448,3)
+00015/0202 7 (256,448,3)
+00015/0312 7 (256,448,3)
+00015/0688 7 (256,448,3)
+00015/0698 7 (256,448,3)
+00015/0788 7 (256,448,3)
+00015/0854 7 (256,448,3)
+00015/0863 7 (256,448,3)
+00015/0864 7 (256,448,3)
+00015/0918 7 (256,448,3)
+00015/0931 7 (256,448,3)
+00016/0276 7 (256,448,3)
+00016/0301 7 (256,448,3)
+00016/0306 7 (256,448,3)
+00016/0324 7 (256,448,3)
+00016/0362 7 (256,448,3)
+00016/0364 7 (256,448,3)
+00016/0370 7 (256,448,3)
+00016/0378 7 (256,448,3)
+00016/0379 7 (256,448,3)
+00016/0402 7 (256,448,3)
+00016/0405 7 (256,448,3)
+00016/0418 7 (256,448,3)
+00016/0419 7 (256,448,3)
+00016/0435 7 (256,448,3)
+00016/0501 7 (256,448,3)
+00016/0561 7 (256,448,3)
+00016/0562 7 (256,448,3)
+00016/0569 7 (256,448,3)
+00016/0591 7 (256,448,3)
+00016/0599 7 (256,448,3)
+00016/0711 7 (256,448,3)
+00016/0713 7 (256,448,3)
+00016/0813 7 (256,448,3)
+00016/0953 7 (256,448,3)
+00016/0960 7 (256,448,3)
+00016/0961 7 (256,448,3)
+00017/0519 7 (256,448,3)
+00017/0523 7 (256,448,3)
+00017/0588 7 (256,448,3)
+00017/0608 7 (256,448,3)
+00017/0609 7 (256,448,3)
+00017/0719 7 (256,448,3)
+00017/0721 7 (256,448,3)
+00017/0727 7 (256,448,3)
+00017/0728 7 (256,448,3)
+00017/0769 7 (256,448,3)
+00017/0775 7 (256,448,3)
+00017/0787 7 (256,448,3)
+00017/0797 7 (256,448,3)
+00018/0043 7 (256,448,3)
+00018/0206 7 (256,448,3)
+00018/0209 7 (256,448,3)
+00018/0211 7 (256,448,3)
+00018/0216 7 (256,448,3)
+00018/0220 7 (256,448,3)
+00018/0221 7 (256,448,3)
+00018/0252 7 (256,448,3)
+00018/0260 7 (256,448,3)
+00018/0331 7 (256,448,3)
+00018/0333 7 (256,448,3)
+00018/0447 7 (256,448,3)
+00018/0523 7 (256,448,3)
+00019/0014 7 (256,448,3)
+00019/0015 7 (256,448,3)
+00019/0019 7 (256,448,3)
+00019/0049 7 (256,448,3)
+00019/0109 7 (256,448,3)
+00019/0114 7 (256,448,3)
+00019/0125 7 (256,448,3)
+00019/0137 7 (256,448,3)
+00019/0140 7 (256,448,3)
+00019/0148 7 (256,448,3)
+00019/0153 7 (256,448,3)
+00019/0155 7 (256,448,3)
+00019/0158 7 (256,448,3)
+00019/0159 7 (256,448,3)
+00019/0160 7 (256,448,3)
+00019/0162 7 (256,448,3)
+00019/0279 7 (256,448,3)
+00019/0282 7 (256,448,3)
+00019/0409 7 (256,448,3)
+00019/0427 7 (256,448,3)
+00019/0430 7 (256,448,3)
+00019/0545 7 (256,448,3)
+00019/0555 7 (256,448,3)
+00019/0558 7 (256,448,3)
+00019/0650 7 (256,448,3)
+00019/0681 7 (256,448,3)
+00019/0747 7 (256,448,3)
+00019/0748 7 (256,448,3)
+00019/0749 7 (256,448,3)
+00019/0752 7 (256,448,3)
+00019/0768 7 (256,448,3)
+00019/0772 7 (256,448,3)
+00019/0773 7 (256,448,3)
+00019/0777 7 (256,448,3)
+00019/0795 7 (256,448,3)
+00019/0806 7 (256,448,3)
+00019/0815 7 (256,448,3)
+00019/0840 7 (256,448,3)
+00019/0844 7 (256,448,3)
+00019/0848 7 (256,448,3)
+00019/0853 7 (256,448,3)
+00019/0863 7 (256,448,3)
+00019/0888 7 (256,448,3)
+00019/0894 7 (256,448,3)
+00019/0901 7 (256,448,3)
+00019/0995 7 (256,448,3)
+00021/0030 7 (256,448,3)
+00021/0035 7 (256,448,3)
+00021/0039 7 (256,448,3)
+00021/0041 7 (256,448,3)
+00021/0044 7 (256,448,3)
+00021/0045 7 (256,448,3)
+00021/0264 7 (256,448,3)
+00021/0330 7 (256,448,3)
+00021/0332 7 (256,448,3)
+00021/0333 7 (256,448,3)
+00021/0336 7 (256,448,3)
+00021/0337 7 (256,448,3)
+00021/0338 7 (256,448,3)
+00021/0343 7 (256,448,3)
+00021/0472 7 (256,448,3)
+00021/0667 7 (256,448,3)
+00021/0731 7 (256,448,3)
+00021/0779 7 (256,448,3)
+00021/0805 7 (256,448,3)
+00021/0814 7 (256,448,3)
+00021/0818 7 (256,448,3)
+00021/0874 7 (256,448,3)
+00022/0008 7 (256,448,3)
+00022/0010 7 (256,448,3)
+00022/0231 7 (256,448,3)
+00022/0323 7 (256,448,3)
+00022/0337 7 (256,448,3)
+00022/0359 7 (256,448,3)
+00022/0377 7 (256,448,3)
+00022/0378 7 (256,448,3)
+00022/0385 7 (256,448,3)
+00022/0393 7 (256,448,3)
+00022/0424 7 (256,448,3)
+00022/0582 7 (256,448,3)
+00022/0583 7 (256,448,3)
+00022/0605 7 (256,448,3)
+00022/0632 7 (256,448,3)
+00022/0633 7 (256,448,3)
+00022/0666 7 (256,448,3)
+00022/0671 7 (256,448,3)
+00022/0673 7 (256,448,3)
+00022/0702 7 (256,448,3)
+00022/0852 7 (256,448,3)
+00022/0853 7 (256,448,3)
+00022/0971 7 (256,448,3)
+00023/0037 7 (256,448,3)
+00023/0224 7 (256,448,3)
+00023/0308 7 (256,448,3)
+00023/0393 7 (256,448,3)
+00023/0633 7 (256,448,3)
+00023/0637 7 (256,448,3)
+00023/0638 7 (256,448,3)
+00023/0770 7 (256,448,3)
+00023/0786 7 (256,448,3)
+00023/0898 7 (256,448,3)
+00024/0247 7 (256,448,3)
+00024/0251 7 (256,448,3)
+00024/0267 7 (256,448,3)
+00024/0288 7 (256,448,3)
+00024/0530 7 (256,448,3)
+00024/0569 7 (256,448,3)
+00024/0587 7 (256,448,3)
+00024/0730 7 (256,448,3)
+00024/0736 7 (256,448,3)
+00024/0742 7 (256,448,3)
+00024/0832 7 (256,448,3)
+00024/0936 7 (256,448,3)
+00025/0044 7 (256,448,3)
+00025/0047 7 (256,448,3)
+00025/0540 7 (256,448,3)
+00025/0552 7 (256,448,3)
+00025/0554 7 (256,448,3)
+00025/0559 7 (256,448,3)
+00025/0572 7 (256,448,3)
+00025/0576 7 (256,448,3)
+00025/0699 7 (256,448,3)
+00025/0709 7 (256,448,3)
+00025/0743 7 (256,448,3)
+00025/0767 7 (256,448,3)
+00025/0780 7 (256,448,3)
+00025/0782 7 (256,448,3)
+00025/0784 7 (256,448,3)
+00025/0791 7 (256,448,3)
+00025/0889 7 (256,448,3)
+00025/0890 7 (256,448,3)
+00025/0894 7 (256,448,3)
+00025/0896 7 (256,448,3)
+00025/0898 7 (256,448,3)
+00025/0905 7 (256,448,3)
+00025/0999 7 (256,448,3)
+00026/0003 7 (256,448,3)
+00026/0005 7 (256,448,3)
+00026/0011 7 (256,448,3)
+00026/0017 7 (256,448,3)
+00026/0036 7 (256,448,3)
+00026/0129 7 (256,448,3)
+00026/0131 7 (256,448,3)
+00026/0161 7 (256,448,3)
+00026/0177 7 (256,448,3)
+00026/0178 7 (256,448,3)
+00026/0180 7 (256,448,3)
+00026/0298 7 (256,448,3)
+00026/0307 7 (256,448,3)
+00026/0308 7 (256,448,3)
+00026/0312 7 (256,448,3)
+00026/0352 7 (256,448,3)
+00026/0440 7 (256,448,3)
+00026/0706 7 (256,448,3)
+00026/0708 7 (256,448,3)
+00026/0715 7 (256,448,3)
+00026/0769 7 (256,448,3)
+00026/0777 7 (256,448,3)
+00026/0779 7 (256,448,3)
+00026/0789 7 (256,448,3)
+00026/0924 7 (256,448,3)
+00026/0928 7 (256,448,3)
+00026/0932 7 (256,448,3)
+00026/0935 7 (256,448,3)
+00027/0118 7 (256,448,3)
+00027/0121 7 (256,448,3)
+00027/0155 7 (256,448,3)
+00027/0168 7 (256,448,3)
+00027/0196 7 (256,448,3)
+00027/0289 7 (256,448,3)
+00027/0294 7 (256,448,3)
+00027/0803 7 (256,448,3)
+00028/0016 7 (256,448,3)
+00028/0045 7 (256,448,3)
+00028/0063 7 (256,448,3)
+00028/0601 7 (256,448,3)
+00028/0638 7 (256,448,3)
+00028/0733 7 (256,448,3)
+00028/0736 7 (256,448,3)
+00028/0741 7 (256,448,3)
+00028/0753 7 (256,448,3)
+00028/0770 7 (256,448,3)
+00028/0771 7 (256,448,3)
+00028/0777 7 (256,448,3)
+00028/0950 7 (256,448,3)
+00028/0951 7 (256,448,3)
+00029/0048 7 (256,448,3)
+00029/0060 7 (256,448,3)
+00029/0362 7 (256,448,3)
+00029/0399 7 (256,448,3)
+00029/0404 7 (256,448,3)
+00029/0412 7 (256,448,3)
+00029/0416 7 (256,448,3)
+00029/0418 7 (256,448,3)
+00029/0428 7 (256,448,3)
+00030/0131 7 (256,448,3)
+00030/0135 7 (256,448,3)
+00030/0150 7 (256,448,3)
+00030/0245 7 (256,448,3)
+00030/0339 7 (256,448,3)
+00030/0472 7 (256,448,3)
+00030/0482 7 (256,448,3)
+00030/0500 7 (256,448,3)
+00030/0501 7 (256,448,3)
+00030/0697 7 (256,448,3)
+00030/0707 7 (256,448,3)
+00030/0733 7 (256,448,3)
+00030/0743 7 (256,448,3)
+00030/0747 7 (256,448,3)
+00030/0754 7 (256,448,3)
+00030/0755 7 (256,448,3)
+00030/0759 7 (256,448,3)
+00030/0762 7 (256,448,3)
+00030/0764 7 (256,448,3)
+00030/0767 7 (256,448,3)
+00030/0794 7 (256,448,3)
+00030/0796 7 (256,448,3)
+00030/0799 7 (256,448,3)
+00030/0814 7 (256,448,3)
+00030/0823 7 (256,448,3)
+00030/0829 7 (256,448,3)
+00030/0833 7 (256,448,3)
+00030/0848 7 (256,448,3)
+00030/0853 7 (256,448,3)
+00030/0861 7 (256,448,3)
+00031/0182 7 (256,448,3)
+00031/0275 7 (256,448,3)
+00031/0279 7 (256,448,3)
+00031/0555 7 (256,448,3)
+00031/0648 7 (256,448,3)
+00031/0663 7 (256,448,3)
+00031/0680 7 (256,448,3)
+00031/0880 7 (256,448,3)
+00031/0922 7 (256,448,3)
+00031/0925 7 (256,448,3)
+00031/0928 7 (256,448,3)
+00032/0025 7 (256,448,3)
+00032/0377 7 (256,448,3)
+00032/0378 7 (256,448,3)
+00032/0382 7 (256,448,3)
+00032/0384 7 (256,448,3)
+00032/0386 7 (256,448,3)
+00032/0389 7 (256,448,3)
+00032/0391 7 (256,448,3)
+00032/0393 7 (256,448,3)
+00032/0492 7 (256,448,3)
+00032/0497 7 (256,448,3)
+00032/0505 7 (256,448,3)
+00032/0523 7 (256,448,3)
+00032/0542 7 (256,448,3)
+00032/0544 7 (256,448,3)
+00032/0712 7 (256,448,3)
+00032/0847 7 (256,448,3)
+00032/0850 7 (256,448,3)
+00032/0875 7 (256,448,3)
+00033/0062 7 (256,448,3)
+00033/0063 7 (256,448,3)
+00033/0098 7 (256,448,3)
+00033/0101 7 (256,448,3)
+00033/0105 7 (256,448,3)
+00033/0114 7 (256,448,3)
+00033/0432 7 (256,448,3)
+00033/0441 7 (256,448,3)
+00033/0606 7 (256,448,3)
+00033/0611 7 (256,448,3)
+00033/0634 7 (256,448,3)
+00033/0787 7 (256,448,3)
+00033/0792 7 (256,448,3)
+00033/0802 7 (256,448,3)
+00033/0825 7 (256,448,3)
+00033/0835 7 (256,448,3)
+00034/0249 7 (256,448,3)
+00034/0253 7 (256,448,3)
+00034/0254 7 (256,448,3)
+00034/0282 7 (256,448,3)
+00034/0318 7 (256,448,3)
+00034/0319 7 (256,448,3)
+00034/0323 7 (256,448,3)
+00034/0336 7 (256,448,3)
+00034/0348 7 (256,448,3)
+00034/0356 7 (256,448,3)
+00034/0379 7 (256,448,3)
+00034/0387 7 (256,448,3)
+00034/0575 7 (256,448,3)
+00034/0608 7 (256,448,3)
+00034/0663 7 (256,448,3)
+00034/0811 7 (256,448,3)
+00034/0812 7 (256,448,3)
+00034/0946 7 (256,448,3)
+00034/0948 7 (256,448,3)
+00034/0950 7 (256,448,3)
+00035/0204 7 (256,448,3)
+00035/0243 7 (256,448,3)
+00035/0308 7 (256,448,3)
+00035/0465 7 (256,448,3)
+00035/0478 7 (256,448,3)
+00035/0523 7 (256,448,3)
+00035/0540 7 (256,448,3)
+00035/0544 7 (256,448,3)
+00035/0556 7 (256,448,3)
+00035/0568 7 (256,448,3)
+00035/0570 7 (256,448,3)
+00035/0609 7 (256,448,3)
+00035/0643 7 (256,448,3)
+00035/0644 7 (256,448,3)
+00035/0645 7 (256,448,3)
+00035/0646 7 (256,448,3)
+00035/0650 7 (256,448,3)
+00035/0661 7 (256,448,3)
+00035/0724 7 (256,448,3)
+00035/0725 7 (256,448,3)
+00035/0850 7 (256,448,3)
+00035/0863 7 (256,448,3)
+00035/0870 7 (256,448,3)
+00035/0951 7 (256,448,3)
+00036/0038 7 (256,448,3)
+00036/0062 7 (256,448,3)
+00036/0423 7 (256,448,3)
+00036/0737 7 (256,448,3)
+00036/0750 7 (256,448,3)
+00036/0751 7 (256,448,3)
+00036/0754 7 (256,448,3)
+00036/0929 7 (256,448,3)
+00037/0085 7 (256,448,3)
+00037/0113 7 (256,448,3)
+00037/0130 7 (256,448,3)
+00037/0153 7 (256,448,3)
+00037/0169 7 (256,448,3)
+00037/0263 7 (256,448,3)
+00037/0272 7 (256,448,3)
+00037/0273 7 (256,448,3)
+00037/0275 7 (256,448,3)
+00037/0280 7 (256,448,3)
+00037/0399 7 (256,448,3)
+00037/0456 7 (256,448,3)
+00037/0853 7 (256,448,3)
+00037/0855 7 (256,448,3)
+00037/0856 7 (256,448,3)
+00037/0857 7 (256,448,3)
+00037/0925 7 (256,448,3)
+00037/0947 7 (256,448,3)
+00038/0148 7 (256,448,3)
+00038/0533 7 (256,448,3)
+00038/0534 7 (256,448,3)
+00038/0560 7 (256,448,3)
+00038/0562 7 (256,448,3)
+00038/0566 7 (256,448,3)
+00038/0578 7 (256,448,3)
+00038/0652 7 (256,448,3)
+00038/0674 7 (256,448,3)
+00038/0685 7 (256,448,3)
+00038/0686 7 (256,448,3)
+00038/0692 7 (256,448,3)
+00038/0736 7 (256,448,3)
+00039/0035 7 (256,448,3)
+00039/0105 7 (256,448,3)
+00039/0109 7 (256,448,3)
+00039/0121 7 (256,448,3)
+00039/0128 7 (256,448,3)
+00039/0129 7 (256,448,3)
+00039/0132 7 (256,448,3)
+00039/0137 7 (256,448,3)
+00039/0157 7 (256,448,3)
+00039/0496 7 (256,448,3)
+00039/0502 7 (256,448,3)
+00039/0526 7 (256,448,3)
+00039/0529 7 (256,448,3)
+00039/0682 7 (256,448,3)
+00039/0690 7 (256,448,3)
+00039/0693 7 (256,448,3)
+00039/0703 7 (256,448,3)
+00039/0725 7 (256,448,3)
+00039/0734 7 (256,448,3)
+00040/0518 7 (256,448,3)
+00040/0728 7 (256,448,3)
+00040/0774 7 (256,448,3)
+00040/0812 7 (256,448,3)
+00040/0818 7 (256,448,3)
+00040/0827 7 (256,448,3)
+00040/0914 7 (256,448,3)
+00040/0917 7 (256,448,3)
+00040/0918 7 (256,448,3)
+00040/0924 7 (256,448,3)
+00040/0925 7 (256,448,3)
+00041/0004 7 (256,448,3)
+00041/0006 7 (256,448,3)
+00041/0013 7 (256,448,3)
+00041/0059 7 (256,448,3)
+00041/0110 7 (256,448,3)
+00041/0291 7 (256,448,3)
+00041/0366 7 (256,448,3)
+00041/0388 7 (256,448,3)
+00041/0434 7 (256,448,3)
+00041/0436 7 (256,448,3)
+00041/0450 7 (256,448,3)
+00041/0457 7 (256,448,3)
+00041/0460 7 (256,448,3)
+00041/0468 7 (256,448,3)
+00041/0471 7 (256,448,3)
+00041/0474 7 (256,448,3)
+00041/0809 7 (256,448,3)
+00041/0844 7 (256,448,3)
+00041/0858 7 (256,448,3)
+00041/0874 7 (256,448,3)
+00041/0876 7 (256,448,3)
+00042/0020 7 (256,448,3)
+00042/0205 7 (256,448,3)
+00042/0206 7 (256,448,3)
+00042/0432 7 (256,448,3)
+00042/0563 7 (256,448,3)
+00042/0569 7 (256,448,3)
+00042/0575 7 (256,448,3)
+00042/0576 7 (256,448,3)
+00042/0888 7 (256,448,3)
+00042/0892 7 (256,448,3)
+00042/0943 7 (256,448,3)
+00042/0944 7 (256,448,3)
+00043/0126 7 (256,448,3)
+00043/0130 7 (256,448,3)
+00043/0136 7 (256,448,3)
+00043/0233 7 (256,448,3)
+00043/0235 7 (256,448,3)
+00043/0237 7 (256,448,3)
+00043/0277 7 (256,448,3)
+00043/0301 7 (256,448,3)
+00043/0302 7 (256,448,3)
+00043/0303 7 (256,448,3)
+00043/0308 7 (256,448,3)
+00043/0309 7 (256,448,3)
+00043/0314 7 (256,448,3)
+00043/0713 7 (256,448,3)
+00043/0715 7 (256,448,3)
+00043/0923 7 (256,448,3)
+00044/0095 7 (256,448,3)
+00044/0255 7 (256,448,3)
+00044/0864 7 (256,448,3)
+00044/0892 7 (256,448,3)
+00044/0898 7 (256,448,3)
+00044/0993 7 (256,448,3)
+00044/0995 7 (256,448,3)
+00044/0997 7 (256,448,3)
+00045/0001 7 (256,448,3)
+00045/0006 7 (256,448,3)
+00045/0269 7 (256,448,3)
+00045/0276 7 (256,448,3)
+00045/0280 7 (256,448,3)
+00045/0281 7 (256,448,3)
+00045/0282 7 (256,448,3)
+00045/0284 7 (256,448,3)
+00045/0550 7 (256,448,3)
+00045/0571 7 (256,448,3)
+00045/0629 7 (256,448,3)
+00045/0631 7 (256,448,3)
+00045/0659 7 (256,448,3)
+00045/0693 7 (256,448,3)
+00045/0807 7 (256,448,3)
+00045/0810 7 (256,448,3)
+00045/0826 7 (256,448,3)
+00045/0849 7 (256,448,3)
+00045/0946 7 (256,448,3)
+00045/0987 7 (256,448,3)
+00045/0990 7 (256,448,3)
+00046/0104 7 (256,448,3)
+00046/0477 7 (256,448,3)
+00046/0490 7 (256,448,3)
+00046/0491 7 (256,448,3)
+00046/0509 7 (256,448,3)
+00046/0513 7 (256,448,3)
+00046/0603 7 (256,448,3)
+00046/0723 7 (256,448,3)
+00046/0744 7 (256,448,3)
+00046/0746 7 (256,448,3)
+00046/0750 7 (256,448,3)
+00046/0852 7 (256,448,3)
+00046/0927 7 (256,448,3)
+00046/0928 7 (256,448,3)
+00046/0929 7 (256,448,3)
+00046/0931 7 (256,448,3)
+00046/0936 7 (256,448,3)
+00046/0939 7 (256,448,3)
+00046/0947 7 (256,448,3)
+00046/0948 7 (256,448,3)
+00046/0950 7 (256,448,3)
+00046/0955 7 (256,448,3)
+00046/0961 7 (256,448,3)
+00047/0023 7 (256,448,3)
+00047/0029 7 (256,448,3)
+00047/0035 7 (256,448,3)
+00047/0058 7 (256,448,3)
+00047/0061 7 (256,448,3)
+00047/0065 7 (256,448,3)
+00047/0068 7 (256,448,3)
+00047/0072 7 (256,448,3)
+00047/0074 7 (256,448,3)
+00047/0148 7 (256,448,3)
+00047/0594 7 (256,448,3)
+00047/0782 7 (256,448,3)
+00047/0787 7 (256,448,3)
+00047/0860 7 (256,448,3)
+00047/0889 7 (256,448,3)
+00047/0893 7 (256,448,3)
+00047/0894 7 (256,448,3)
+00047/0902 7 (256,448,3)
+00047/0975 7 (256,448,3)
+00047/0995 7 (256,448,3)
+00048/0033 7 (256,448,3)
+00048/0113 7 (256,448,3)
+00048/0115 7 (256,448,3)
+00048/0120 7 (256,448,3)
+00048/0129 7 (256,448,3)
+00048/0136 7 (256,448,3)
+00048/0327 7 (256,448,3)
+00048/0329 7 (256,448,3)
+00048/0341 7 (256,448,3)
+00048/0343 7 (256,448,3)
+00048/0345 7 (256,448,3)
+00048/0346 7 (256,448,3)
+00048/0355 7 (256,448,3)
+00048/0359 7 (256,448,3)
+00048/0363 7 (256,448,3)
+00048/0378 7 (256,448,3)
+00048/0386 7 (256,448,3)
+00048/0387 7 (256,448,3)
+00048/0388 7 (256,448,3)
+00048/0428 7 (256,448,3)
+00048/0439 7 (256,448,3)
+00048/0507 7 (256,448,3)
+00048/0510 7 (256,448,3)
+00048/0512 7 (256,448,3)
+00048/0514 7 (256,448,3)
+00048/0539 7 (256,448,3)
+00048/0542 7 (256,448,3)
+00048/0544 7 (256,448,3)
+00048/0631 7 (256,448,3)
+00048/0632 7 (256,448,3)
+00048/0636 7 (256,448,3)
+00048/0640 7 (256,448,3)
+00048/0644 7 (256,448,3)
+00048/0653 7 (256,448,3)
+00048/0655 7 (256,448,3)
+00048/0658 7 (256,448,3)
+00048/0667 7 (256,448,3)
+00048/0688 7 (256,448,3)
+00048/0708 7 (256,448,3)
+00049/0005 7 (256,448,3)
+00049/0074 7 (256,448,3)
+00049/0077 7 (256,448,3)
+00049/0084 7 (256,448,3)
+00049/0516 7 (256,448,3)
+00049/0800 7 (256,448,3)
+00049/0900 7 (256,448,3)
+00050/0607 7 (256,448,3)
+00050/0661 7 (256,448,3)
+00050/0665 7 (256,448,3)
+00050/0685 7 (256,448,3)
+00050/0711 7 (256,448,3)
+00051/0068 7 (256,448,3)
+00051/0069 7 (256,448,3)
+00051/0076 7 (256,448,3)
+00051/0569 7 (256,448,3)
+00051/0801 7 (256,448,3)
+00051/0927 7 (256,448,3)
+00051/0945 7 (256,448,3)
+00051/0952 7 (256,448,3)
+00051/0976 7 (256,448,3)
+00051/0985 7 (256,448,3)
+00052/0012 7 (256,448,3)
+00052/0015 7 (256,448,3)
+00052/0052 7 (256,448,3)
+00052/0056 7 (256,448,3)
+00052/0060 7 (256,448,3)
+00052/0157 7 (256,448,3)
+00052/0265 7 (256,448,3)
+00052/0788 7 (256,448,3)
+00052/0790 7 (256,448,3)
+00052/0793 7 (256,448,3)
+00052/0816 7 (256,448,3)
+00052/0824 7 (256,448,3)
+00052/0918 7 (256,448,3)
+00052/0933 7 (256,448,3)
+00052/0947 7 (256,448,3)
+00053/0232 7 (256,448,3)
+00053/0277 7 (256,448,3)
+00053/0362 7 (256,448,3)
+00053/0577 7 (256,448,3)
+00053/0609 7 (256,448,3)
+00053/0612 7 (256,448,3)
+00053/0628 7 (256,448,3)
+00053/0629 7 (256,448,3)
+00053/0633 7 (256,448,3)
+00053/0659 7 (256,448,3)
+00053/0667 7 (256,448,3)
+00053/0671 7 (256,448,3)
+00053/0797 7 (256,448,3)
+00053/0804 7 (256,448,3)
+00053/0807 7 (256,448,3)
+00053/0952 7 (256,448,3)
+00053/0970 7 (256,448,3)
+00053/0981 7 (256,448,3)
+00053/0999 7 (256,448,3)
+00054/0003 7 (256,448,3)
+00054/0013 7 (256,448,3)
+00054/0020 7 (256,448,3)
+00054/0022 7 (256,448,3)
+00054/0023 7 (256,448,3)
+00054/0044 7 (256,448,3)
+00054/0051 7 (256,448,3)
+00054/0063 7 (256,448,3)
+00054/0065 7 (256,448,3)
+00054/0145 7 (256,448,3)
+00054/0153 7 (256,448,3)
+00054/0203 7 (256,448,3)
+00054/0325 7 (256,448,3)
+00054/0445 7 (256,448,3)
+00054/0448 7 (256,448,3)
+00054/0456 7 (256,448,3)
+00054/0457 7 (256,448,3)
+00054/0519 7 (256,448,3)
+00054/0524 7 (256,448,3)
+00054/0530 7 (256,448,3)
+00054/0532 7 (256,448,3)
+00054/0535 7 (256,448,3)
+00054/0574 7 (256,448,3)
+00054/0760 7 (256,448,3)
+00054/0767 7 (256,448,3)
+00054/0837 7 (256,448,3)
+00055/0011 7 (256,448,3)
+00055/0109 7 (256,448,3)
+00055/0111 7 (256,448,3)
+00055/0117 7 (256,448,3)
+00055/0119 7 (256,448,3)
+00055/0182 7 (256,448,3)
+00055/0192 7 (256,448,3)
+00055/0193 7 (256,448,3)
+00055/0200 7 (256,448,3)
+00055/0204 7 (256,448,3)
+00055/0207 7 (256,448,3)
+00055/0212 7 (256,448,3)
+00055/0213 7 (256,448,3)
+00055/0348 7 (256,448,3)
+00055/0423 7 (256,448,3)
+00055/0427 7 (256,448,3)
+00055/0456 7 (256,448,3)
+00055/0489 7 (256,448,3)
+00055/0689 7 (256,448,3)
+00055/0753 7 (256,448,3)
+00055/0802 7 (256,448,3)
+00055/0844 7 (256,448,3)
+00055/0850 7 (256,448,3)
+00055/0982 7 (256,448,3)
+00055/0993 7 (256,448,3)
+00056/0113 7 (256,448,3)
+00056/0148 7 (256,448,3)
+00056/0151 7 (256,448,3)
+00056/0316 7 (256,448,3)
+00056/0379 7 (256,448,3)
+00056/0380 7 (256,448,3)
+00056/0385 7 (256,448,3)
+00056/0505 7 (256,448,3)
+00056/0579 7 (256,448,3)
+00057/0254 7 (256,448,3)
+00057/0264 7 (256,448,3)
+00057/0272 7 (256,448,3)
+00057/0403 7 (256,448,3)
+00057/0501 7 (256,448,3)
+00057/0503 7 (256,448,3)
+00057/0884 7 (256,448,3)
+00058/0026 7 (256,448,3)
+00058/0029 7 (256,448,3)
+00058/0104 7 (256,448,3)
+00058/0124 7 (256,448,3)
+00058/0162 7 (256,448,3)
+00058/0288 7 (256,448,3)
+00058/0289 7 (256,448,3)
+00058/0323 7 (256,448,3)
+00058/0328 7 (256,448,3)
+00058/0329 7 (256,448,3)
+00058/0337 7 (256,448,3)
+00058/0367 7 (256,448,3)
+00058/0383 7 (256,448,3)
+00058/0395 7 (256,448,3)
+00060/0178 7 (256,448,3)
+00060/0182 7 (256,448,3)
+00061/0001 7 (256,448,3)
+00061/0003 7 (256,448,3)
+00061/0006 7 (256,448,3)
+00061/0443 7 (256,448,3)
+00061/0586 7 (256,448,3)
+00061/0587 7 (256,448,3)
+00061/0774 7 (256,448,3)
+00061/0789 7 (256,448,3)
+00061/0815 7 (256,448,3)
+00061/0817 7 (256,448,3)
+00061/0826 7 (256,448,3)
+00061/0829 7 (256,448,3)
+00061/0830 7 (256,448,3)
+00061/0832 7 (256,448,3)
+00061/0833 7 (256,448,3)
+00061/0836 7 (256,448,3)
+00061/0837 7 (256,448,3)
+00061/0839 7 (256,448,3)
+00061/0843 7 (256,448,3)
+00061/0849 7 (256,448,3)
+00061/0859 7 (256,448,3)
+00061/0861 7 (256,448,3)
+00061/0868 7 (256,448,3)
+00061/0877 7 (256,448,3)
+00061/0889 7 (256,448,3)
+00061/0905 7 (256,448,3)
+00062/0115 7 (256,448,3)
+00062/0118 7 (256,448,3)
+00062/0125 7 (256,448,3)
+00062/0134 7 (256,448,3)
+00062/0142 7 (256,448,3)
+00062/0400 7 (256,448,3)
+00062/0457 7 (256,448,3)
+00062/0459 7 (256,448,3)
+00062/0560 7 (256,448,3)
+00062/0650 7 (256,448,3)
+00062/0655 7 (256,448,3)
+00062/0715 7 (256,448,3)
+00062/0847 7 (256,448,3)
+00062/0905 7 (256,448,3)
+00062/0981 7 (256,448,3)
+00063/0177 7 (256,448,3)
+00063/0230 7 (256,448,3)
+00063/0253 7 (256,448,3)
+00063/0257 7 (256,448,3)
+00063/0326 7 (256,448,3)
+00063/0530 7 (256,448,3)
+00063/0677 7 (256,448,3)
+00063/0759 7 (256,448,3)
+00063/0761 7 (256,448,3)
+00063/0777 7 (256,448,3)
+00063/0842 7 (256,448,3)
+00063/0900 7 (256,448,3)
+00064/0014 7 (256,448,3)
+00064/0028 7 (256,448,3)
+00064/0029 7 (256,448,3)
+00064/0030 7 (256,448,3)
+00064/0037 7 (256,448,3)
+00064/0044 7 (256,448,3)
+00064/0280 7 (256,448,3)
+00064/0285 7 (256,448,3)
+00064/0286 7 (256,448,3)
+00064/0291 7 (256,448,3)
+00064/0300 7 (256,448,3)
+00064/0303 7 (256,448,3)
+00064/0308 7 (256,448,3)
+00064/0314 7 (256,448,3)
+00064/0316 7 (256,448,3)
+00064/0317 7 (256,448,3)
+00064/0323 7 (256,448,3)
+00064/0435 7 (256,448,3)
+00064/0733 7 (256,448,3)
+00064/0848 7 (256,448,3)
+00064/0868 7 (256,448,3)
+00064/0888 7 (256,448,3)
+00064/0898 7 (256,448,3)
+00065/0116 7 (256,448,3)
+00065/0121 7 (256,448,3)
+00065/0122 7 (256,448,3)
+00065/0124 7 (256,448,3)
+00065/0125 7 (256,448,3)
+00065/0126 7 (256,448,3)
+00065/0136 7 (256,448,3)
+00065/0146 7 (256,448,3)
+00065/0147 7 (256,448,3)
+00065/0163 7 (256,448,3)
+00065/0170 7 (256,448,3)
+00065/0175 7 (256,448,3)
+00065/0176 7 (256,448,3)
+00065/0180 7 (256,448,3)
+00065/0184 7 (256,448,3)
+00065/0186 7 (256,448,3)
+00065/0332 7 (256,448,3)
+00065/0343 7 (256,448,3)
+00065/0365 7 (256,448,3)
+00065/0393 7 (256,448,3)
+00065/0394 7 (256,448,3)
+00065/0442 7 (256,448,3)
+00065/0459 7 (256,448,3)
+00065/0462 7 (256,448,3)
+00065/0476 7 (256,448,3)
+00065/0483 7 (256,448,3)
+00065/0590 7 (256,448,3)
+00065/0593 7 (256,448,3)
+00065/0595 7 (256,448,3)
+00065/0774 7 (256,448,3)
+00065/0947 7 (256,448,3)
+00065/0985 7 (256,448,3)
+00065/0986 7 (256,448,3)
+00066/0015 7 (256,448,3)
+00066/0043 7 (256,448,3)
+00066/0131 7 (256,448,3)
+00066/0157 7 (256,448,3)
+00066/0169 7 (256,448,3)
+00066/0374 7 (256,448,3)
+00066/0382 7 (256,448,3)
+00066/0481 7 (256,448,3)
+00066/0482 7 (256,448,3)
+00066/0491 7 (256,448,3)
+00066/0493 7 (256,448,3)
+00066/0494 7 (256,448,3)
+00066/0496 7 (256,448,3)
+00066/0680 7 (256,448,3)
+00066/0700 7 (256,448,3)
+00066/0887 7 (256,448,3)
+00066/0910 7 (256,448,3)
+00066/0918 7 (256,448,3)
+00067/0024 7 (256,448,3)
+00067/0059 7 (256,448,3)
+00067/0408 7 (256,448,3)
+00067/0414 7 (256,448,3)
+00067/0417 7 (256,448,3)
+00067/0419 7 (256,448,3)
+00067/0423 7 (256,448,3)
+00067/0441 7 (256,448,3)
+00067/0467 7 (256,448,3)
+00067/0471 7 (256,448,3)
+00067/0487 7 (256,448,3)
+00067/0494 7 (256,448,3)
+00067/0497 7 (256,448,3)
+00067/0513 7 (256,448,3)
+00067/0521 7 (256,448,3)
+00068/0111 7 (256,448,3)
+00068/0123 7 (256,448,3)
+00068/0126 7 (256,448,3)
+00068/0129 7 (256,448,3)
+00068/0270 7 (256,448,3)
+00068/0330 7 (256,448,3)
+00068/0407 7 (256,448,3)
+00068/0428 7 (256,448,3)
+00068/0544 7 (256,448,3)
+00068/0635 7 (256,448,3)
+00068/0637 7 (256,448,3)
+00068/0736 7 (256,448,3)
+00068/0738 7 (256,448,3)
+00068/0747 7 (256,448,3)
+00068/0748 7 (256,448,3)
+00068/0749 7 (256,448,3)
+00068/0762 7 (256,448,3)
+00068/0815 7 (256,448,3)
+00068/0981 7 (256,448,3)
+00068/0982 7 (256,448,3)
+00069/0187 7 (256,448,3)
+00069/0191 7 (256,448,3)
+00070/0001 7 (256,448,3)
+00070/0003 7 (256,448,3)
+00070/0340 7 (256,448,3)
+00070/0341 7 (256,448,3)
+00070/0342 7 (256,448,3)
+00070/0347 7 (256,448,3)
+00070/0372 7 (256,448,3)
+00070/0383 7 (256,448,3)
+00070/0389 7 (256,448,3)
+00070/0728 7 (256,448,3)
+00070/0813 7 (256,448,3)
+00070/0814 7 (256,448,3)
+00070/0823 7 (256,448,3)
+00070/0840 7 (256,448,3)
+00070/0843 7 (256,448,3)
+00070/0861 7 (256,448,3)
+00071/0111 7 (256,448,3)
+00071/0138 7 (256,448,3)
+00071/0143 7 (256,448,3)
+00071/0150 7 (256,448,3)
+00071/0508 7 (256,448,3)
+00071/0514 7 (256,448,3)
+00071/0550 7 (256,448,3)
+00071/0556 7 (256,448,3)
+00071/0600 7 (256,448,3)
+00071/0665 7 (256,448,3)
+00071/0670 7 (256,448,3)
+00071/0672 7 (256,448,3)
+00071/0673 7 (256,448,3)
+00071/0705 7 (256,448,3)
+00071/0706 7 (256,448,3)
+00071/0707 7 (256,448,3)
+00071/0774 7 (256,448,3)
+00071/0799 7 (256,448,3)
+00071/0814 7 (256,448,3)
+00071/0816 7 (256,448,3)
+00071/0819 7 (256,448,3)
+00071/0823 7 (256,448,3)
+00071/0828 7 (256,448,3)
+00071/0830 7 (256,448,3)
+00071/0839 7 (256,448,3)
+00071/0841 7 (256,448,3)
+00072/0192 7 (256,448,3)
+00072/0194 7 (256,448,3)
+00072/0197 7 (256,448,3)
+00072/0199 7 (256,448,3)
+00072/0285 7 (256,448,3)
+00072/0586 7 (256,448,3)
+00072/0795 7 (256,448,3)
+00072/0811 7 (256,448,3)
+00072/0812 7 (256,448,3)
+00072/0824 7 (256,448,3)
+00072/0831 7 (256,448,3)
+00072/0835 7 (256,448,3)
+00072/0837 7 (256,448,3)
+00072/0841 7 (256,448,3)
+00072/0962 7 (256,448,3)
+00073/0296 7 (256,448,3)
+00073/0299 7 (256,448,3)
+00073/0300 7 (256,448,3)
+00073/0301 7 (256,448,3)
+00073/0427 7 (256,448,3)
+00073/0428 7 (256,448,3)
+00073/0494 7 (256,448,3)
+00073/0615 7 (256,448,3)
+00073/0620 7 (256,448,3)
+00073/0624 7 (256,448,3)
+00073/0979 7 (256,448,3)
+00074/0226 7 (256,448,3)
+00074/0250 7 (256,448,3)
+00074/0284 7 (256,448,3)
+00074/0503 7 (256,448,3)
+00074/0614 7 (256,448,3)
+00074/0629 7 (256,448,3)
+00074/0762 7 (256,448,3)
+00074/0765 7 (256,448,3)
+00074/0900 7 (256,448,3)
+00074/0908 7 (256,448,3)
+00075/0352 7 (256,448,3)
+00075/0360 7 (256,448,3)
+00075/0361 7 (256,448,3)
+00075/0365 7 (256,448,3)
+00075/0383 7 (256,448,3)
+00075/0384 7 (256,448,3)
+00075/0386 7 (256,448,3)
+00075/0407 7 (256,448,3)
+00075/0410 7 (256,448,3)
+00075/0412 7 (256,448,3)
+00075/0413 7 (256,448,3)
+00075/0459 7 (256,448,3)
+00075/0504 7 (256,448,3)
+00075/0515 7 (256,448,3)
+00075/0518 7 (256,448,3)
+00075/0567 7 (256,448,3)
+00075/0681 7 (256,448,3)
+00075/0693 7 (256,448,3)
+00075/0728 7 (256,448,3)
+00075/0731 7 (256,448,3)
+00075/0804 7 (256,448,3)
+00075/0974 7 (256,448,3)
+00075/0975 7 (256,448,3)
+00075/0983 7 (256,448,3)
+00075/0997 7 (256,448,3)
+00076/0006 7 (256,448,3)
+00076/0007 7 (256,448,3)
+00076/0011 7 (256,448,3)
+00076/0013 7 (256,448,3)
+00076/0014 7 (256,448,3)
+00076/0027 7 (256,448,3)
+00076/0029 7 (256,448,3)
+00076/0037 7 (256,448,3)
+00076/0041 7 (256,448,3)
+00076/0055 7 (256,448,3)
+00076/0071 7 (256,448,3)
+00076/0172 7 (256,448,3)
+00076/0275 7 (256,448,3)
+00076/0286 7 (256,448,3)
+00076/0467 7 (256,448,3)
+00076/0481 7 (256,448,3)
+00076/0527 7 (256,448,3)
+00076/0895 7 (256,448,3)
+00076/0896 7 (256,448,3)
+00076/0906 7 (256,448,3)
+00076/0924 7 (256,448,3)
+00076/0964 7 (256,448,3)
+00076/0984 7 (256,448,3)
+00077/0317 7 (256,448,3)
+00077/0322 7 (256,448,3)
+00077/0333 7 (256,448,3)
+00077/0334 7 (256,448,3)
+00077/0480 7 (256,448,3)
+00077/0488 7 (256,448,3)
+00077/0490 7 (256,448,3)
+00077/0582 7 (256,448,3)
+00077/0586 7 (256,448,3)
+00077/0969 7 (256,448,3)
+00078/0007 7 (256,448,3)
+00078/0011 7 (256,448,3)
+00078/0153 7 (256,448,3)
+00078/0289 7 (256,448,3)
+00078/0312 7 (256,448,3)
+00078/0492 7 (256,448,3)
+00078/0580 7 (256,448,3)
+00078/0595 7 (256,448,3)
+00078/0814 7 (256,448,3)
+00078/0950 7 (256,448,3)
+00078/0955 7 (256,448,3)
+00079/0060 7 (256,448,3)
+00079/0067 7 (256,448,3)
+00080/0216 7 (256,448,3)
+00080/0308 7 (256,448,3)
+00080/0504 7 (256,448,3)
+00080/0552 7 (256,448,3)
+00080/0576 7 (256,448,3)
+00080/0583 7 (256,448,3)
+00080/0837 7 (256,448,3)
+00080/0839 7 (256,448,3)
+00080/0871 7 (256,448,3)
+00080/0877 7 (256,448,3)
+00080/0880 7 (256,448,3)
+00080/0969 7 (256,448,3)
+00080/0973 7 (256,448,3)
+00080/0980 7 (256,448,3)
+00081/0202 7 (256,448,3)
+00081/0203 7 (256,448,3)
+00081/0210 7 (256,448,3)
+00081/0268 7 (256,448,3)
+00081/0281 7 (256,448,3)
+00081/0283 7 (256,448,3)
+00081/0317 7 (256,448,3)
+00081/0327 7 (256,448,3)
+00082/0018 7 (256,448,3)
+00082/0025 7 (256,448,3)
+00082/0089 7 (256,448,3)
+00082/0140 7 (256,448,3)
+00082/0442 7 (256,448,3)
+00082/0465 7 (256,448,3)
+00082/0473 7 (256,448,3)
+00082/0481 7 (256,448,3)
+00082/0492 7 (256,448,3)
+00082/0495 7 (256,448,3)
+00082/0497 7 (256,448,3)
+00082/0502 7 (256,448,3)
+00082/0504 7 (256,448,3)
+00082/0506 7 (256,448,3)
+00082/0507 7 (256,448,3)
+00082/0510 7 (256,448,3)
+00082/0519 7 (256,448,3)
+00082/0523 7 (256,448,3)
+00082/0588 7 (256,448,3)
+00082/0597 7 (256,448,3)
+00082/0632 7 (256,448,3)
+00082/0751 7 (256,448,3)
+00082/0767 7 (256,448,3)
+00082/0771 7 (256,448,3)
+00082/0790 7 (256,448,3)
+00082/0804 7 (256,448,3)
+00082/0823 7 (256,448,3)
+00083/0052 7 (256,448,3)
+00083/0056 7 (256,448,3)
+00083/0113 7 (256,448,3)
+00083/0114 7 (256,448,3)
+00083/0122 7 (256,448,3)
+00083/0137 7 (256,448,3)
+00083/0270 7 (256,448,3)
+00083/0295 7 (256,448,3)
+00083/0303 7 (256,448,3)
+00083/0308 7 (256,448,3)
+00083/0586 7 (256,448,3)
+00083/0592 7 (256,448,3)
+00083/0640 7 (256,448,3)
+00083/0648 7 (256,448,3)
+00083/0654 7 (256,448,3)
+00083/0662 7 (256,448,3)
+00083/0666 7 (256,448,3)
+00083/0668 7 (256,448,3)
+00083/0669 7 (256,448,3)
+00083/0675 7 (256,448,3)
+00083/0679 7 (256,448,3)
+00083/0681 7 (256,448,3)
+00083/0682 7 (256,448,3)
+00083/0694 7 (256,448,3)
+00083/0695 7 (256,448,3)
+00083/0697 7 (256,448,3)
+00083/0704 7 (256,448,3)
+00083/0713 7 (256,448,3)
+00083/0721 7 (256,448,3)
+00083/0855 7 (256,448,3)
+00084/0109 7 (256,448,3)
+00084/0113 7 (256,448,3)
+00084/0306 7 (256,448,3)
+00084/0442 7 (256,448,3)
+00084/0669 7 (256,448,3)
+00084/0679 7 (256,448,3)
+00084/0685 7 (256,448,3)
+00084/0691 7 (256,448,3)
+00084/0768 7 (256,448,3)
+00084/0817 7 (256,448,3)
+00085/0027 7 (256,448,3)
+00085/0035 7 (256,448,3)
+00085/0038 7 (256,448,3)
+00085/0223 7 (256,448,3)
+00085/0233 7 (256,448,3)
+00085/0281 7 (256,448,3)
+00085/0287 7 (256,448,3)
+00085/0313 7 (256,448,3)
+00085/0521 7 (256,448,3)
+00085/0848 7 (256,448,3)
+00085/0855 7 (256,448,3)
+00085/0865 7 (256,448,3)
+00085/0952 7 (256,448,3)
+00085/0964 7 (256,448,3)
+00085/0973 7 (256,448,3)
+00085/0986 7 (256,448,3)
+00085/0993 7 (256,448,3)
+00086/0070 7 (256,448,3)
+00086/0075 7 (256,448,3)
+00086/0094 7 (256,448,3)
+00086/0103 7 (256,448,3)
+00086/0112 7 (256,448,3)
+00086/0288 7 (256,448,3)
+00086/0576 7 (256,448,3)
+00086/0580 7 (256,448,3)
+00086/0584 7 (256,448,3)
+00086/0599 7 (256,448,3)
+00086/0600 7 (256,448,3)
+00086/0602 7 (256,448,3)
+00086/0612 7 (256,448,3)
+00086/0629 7 (256,448,3)
+00086/0655 7 (256,448,3)
+00086/0679 7 (256,448,3)
+00086/0694 7 (256,448,3)
+00086/0695 7 (256,448,3)
+00086/0701 7 (256,448,3)
+00086/0760 7 (256,448,3)
+00086/0786 7 (256,448,3)
+00086/0845 7 (256,448,3)
+00086/0868 7 (256,448,3)
+00086/0889 7 (256,448,3)
+00086/0891 7 (256,448,3)
+00086/0927 7 (256,448,3)
+00086/0938 7 (256,448,3)
+00086/0946 7 (256,448,3)
+00086/0963 7 (256,448,3)
+00086/0969 7 (256,448,3)
+00087/0023 7 (256,448,3)
+00087/0029 7 (256,448,3)
+00087/0144 7 (256,448,3)
+00087/0148 7 (256,448,3)
+00087/0159 7 (256,448,3)
+00087/0174 7 (256,448,3)
+00087/0283 7 (256,448,3)
+00087/0284 7 (256,448,3)
+00087/0294 7 (256,448,3)
+00087/0296 7 (256,448,3)
+00087/0498 7 (256,448,3)
+00087/0502 7 (256,448,3)
+00087/0532 7 (256,448,3)
+00087/0557 7 (256,448,3)
+00087/0559 7 (256,448,3)
+00087/0574 7 (256,448,3)
+00087/0577 7 (256,448,3)
+00088/0006 7 (256,448,3)
+00088/0268 7 (256,448,3)
+00088/0320 7 (256,448,3)
+00088/0412 7 (256,448,3)
+00088/0431 7 (256,448,3)
+00088/0432 7 (256,448,3)
+00088/0465 7 (256,448,3)
+00088/0507 7 (256,448,3)
+00088/0565 7 (256,448,3)
+00088/0629 7 (256,448,3)
+00088/0831 7 (256,448,3)
+00088/0836 7 (256,448,3)
+00088/0972 7 (256,448,3)
+00088/0974 7 (256,448,3)
+00088/0980 7 (256,448,3)
+00089/0067 7 (256,448,3)
+00089/0244 7 (256,448,3)
+00089/0404 7 (256,448,3)
+00089/0416 7 (256,448,3)
+00089/0419 7 (256,448,3)
+00089/0428 7 (256,448,3)
+00089/0712 7 (256,448,3)
+00089/0713 7 (256,448,3)
+00089/0723 7 (256,448,3)
+00089/0727 7 (256,448,3)
+00089/0770 7 (256,448,3)
+00089/0809 7 (256,448,3)
+00089/0811 7 (256,448,3)
+00089/0888 7 (256,448,3)
+00089/0898 7 (256,448,3)
+00089/0903 7 (256,448,3)
+00089/0907 7 (256,448,3)
+00089/0911 7 (256,448,3)
+00089/0915 7 (256,448,3)
+00089/0926 7 (256,448,3)
+00089/0955 7 (256,448,3)
+00090/0027 7 (256,448,3)
+00090/0028 7 (256,448,3)
+00090/0032 7 (256,448,3)
+00090/0038 7 (256,448,3)
+00090/0076 7 (256,448,3)
+00090/0081 7 (256,448,3)
+00090/0086 7 (256,448,3)
+00090/0119 7 (256,448,3)
+00090/0258 7 (256,448,3)
+00090/0261 7 (256,448,3)
+00090/0447 7 (256,448,3)
+00090/0498 7 (256,448,3)
+00090/0514 7 (256,448,3)
+00090/0523 7 (256,448,3)
+00090/0530 7 (256,448,3)
+00090/0540 7 (256,448,3)
+00090/0548 7 (256,448,3)
+00090/0565 7 (256,448,3)
+00090/0578 7 (256,448,3)
+00090/0580 7 (256,448,3)
+00090/0581 7 (256,448,3)
+00090/0780 7 (256,448,3)
+00090/0940 7 (256,448,3)
+00090/0984 7 (256,448,3)
+00091/0023 7 (256,448,3)
+00091/0051 7 (256,448,3)
+00091/0317 7 (256,448,3)
+00091/0320 7 (256,448,3)
+00091/0582 7 (256,448,3)
+00091/0585 7 (256,448,3)
+00091/0588 7 (256,448,3)
+00091/0601 7 (256,448,3)
+00091/0602 7 (256,448,3)
+00091/0603 7 (256,448,3)
+00091/0634 7 (256,448,3)
+00091/0693 7 (256,448,3)
+00091/0741 7 (256,448,3)
+00091/0966 7 (256,448,3)
+00091/0973 7 (256,448,3)
+00091/0985 7 (256,448,3)
+00092/0007 7 (256,448,3)
+00092/0132 7 (256,448,3)
+00092/0270 7 (256,448,3)
+00092/0296 7 (256,448,3)
+00092/0611 7 (256,448,3)
+00092/0625 7 (256,448,3)
+00092/0627 7 (256,448,3)
+00092/0651 7 (256,448,3)
+00092/0652 7 (256,448,3)
+00092/0910 7 (256,448,3)
+00093/0075 7 (256,448,3)
+00093/0078 7 (256,448,3)
+00093/0100 7 (256,448,3)
+00093/0132 7 (256,448,3)
+00093/0133 7 (256,448,3)
+00093/0176 7 (256,448,3)
+00093/0177 7 (256,448,3)
+00093/0178 7 (256,448,3)
+00093/0181 7 (256,448,3)
+00093/0183 7 (256,448,3)
+00093/0184 7 (256,448,3)
+00093/0286 7 (256,448,3)
+00093/0304 7 (256,448,3)
+00093/0305 7 (256,448,3)
+00093/0319 7 (256,448,3)
+00093/0324 7 (256,448,3)
+00093/0325 7 (256,448,3)
+00093/0327 7 (256,448,3)
+00093/0331 7 (256,448,3)
+00093/0444 7 (256,448,3)
+00093/0450 7 (256,448,3)
+00093/0593 7 (256,448,3)
+00094/0032 7 (256,448,3)
+00094/0057 7 (256,448,3)
+00094/0139 7 (256,448,3)
+00094/0206 7 (256,448,3)
+00094/0211 7 (256,448,3)
+00094/0215 7 (256,448,3)
+00094/0218 7 (256,448,3)
+00094/0257 7 (256,448,3)
+00094/0329 7 (256,448,3)
+00094/0331 7 (256,448,3)
+00094/0332 7 (256,448,3)
+00094/0369 7 (256,448,3)
+00094/0370 7 (256,448,3)
+00094/0383 7 (256,448,3)
+00094/0385 7 (256,448,3)
+00094/0387 7 (256,448,3)
+00094/0399 7 (256,448,3)
+00094/0605 7 (256,448,3)
+00094/0648 7 (256,448,3)
+00094/0649 7 (256,448,3)
+00094/0759 7 (256,448,3)
+00094/0800 7 (256,448,3)
+00094/0894 7 (256,448,3)
+00094/0896 7 (256,448,3)
+00095/0089 7 (256,448,3)
+00095/0108 7 (256,448,3)
+00095/0109 7 (256,448,3)
+00095/0114 7 (256,448,3)
+00095/0128 7 (256,448,3)
+00095/0133 7 (256,448,3)
+00095/0150 7 (256,448,3)
+00095/0153 7 (256,448,3)
+00095/0154 7 (256,448,3)
+00095/0196 7 (256,448,3)
+00095/0209 7 (256,448,3)
+00095/0228 7 (256,448,3)
+00095/0230 7 (256,448,3)
+00095/0231 7 (256,448,3)
+00095/0242 7 (256,448,3)
+00095/0243 7 (256,448,3)
+00095/0253 7 (256,448,3)
+00095/0280 7 (256,448,3)
+00095/0281 7 (256,448,3)
+00095/0283 7 (256,448,3)
+00095/0314 7 (256,448,3)
+00095/0868 7 (256,448,3)
+00095/0894 7 (256,448,3)
+00096/0062 7 (256,448,3)
+00096/0347 7 (256,448,3)
+00096/0348 7 (256,448,3)
+00096/0359 7 (256,448,3)
+00096/0363 7 (256,448,3)
+00096/0373 7 (256,448,3)
+00096/0378 7 (256,448,3)
+00096/0387 7 (256,448,3)
+00096/0395 7 (256,448,3)
+00096/0396 7 (256,448,3)
+00096/0404 7 (256,448,3)
+00096/0653 7 (256,448,3)
+00096/0668 7 (256,448,3)
+00096/0679 7 (256,448,3)
+00096/0729 7 (256,448,3)
+00096/0736 7 (256,448,3)
+00096/0823 7 (256,448,3)

NAFNet/basicsr/data/paired_image_SR_LR_FullImage_Memory_dataset.py

@@ -0,0 +1,296 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+from torch.utils import data as data
+from torchvision.transforms.functional import normalize, resize
+
+from basicsr.data.data_util import (paired_paths_from_folder,
+                                    paired_paths_from_lmdb,
+                                    paired_paths_from_meta_info_file)
+from basicsr.data.transforms import augment, paired_random_crop_hw
+from basicsr.utils import FileClient, imfrombytes, img2tensor, padding
+import os
+import numpy as np
+
+import pickle
+
+
+class PairedImageSRLRFullImageMemoryDataset(data.Dataset):
+    """Paired image dataset for image restoration.
+
+    Read LQ (Low Quality, e.g. LR (Low Resolution), blurry, noisy, etc) and
+    GT image pairs.
+
+    There are three modes:
+    1. 'lmdb': Use lmdb files.
+        If opt['io_backend'] == lmdb.
+    2. 'meta_info_file': Use meta information file to generate paths.
+        If opt['io_backend'] != lmdb and opt['meta_info_file'] is not None.
+    3. 'folder': Scan folders to generate paths.
+        The rest.
+
+    Args:
+        opt (dict): Config for train datasets. It contains the following keys:
+            dataroot_gt (str): Data root path for gt.
+            dataroot_lq (str): Data root path for lq.
+            meta_info_file (str): Path for meta information file.
+            io_backend (dict): IO backend type and other kwarg.
+            filename_tmpl (str): Template for each filename. Note that the
+                template excludes the file extension. Default: '{}'.
+            gt_size (int): Cropped patched size for gt patches.
+            use_flip (bool): Use horizontal flips.
+            use_rot (bool): Use rotation (use vertical flip and transposing h
+                and w for implementation).
+
+            scale (bool): Scale, which will be added automatically.
+            phase (str): 'train' or 'val'.
+    """
+
+    def __init__(self, opt):
+        super(PairedImageSRLRFullImageMemoryDataset, self).__init__()
+        self.opt = opt
+        # file client (io backend)
+        self.file_client = None
+        # self.io_backend_opt = opt['io_backend']
+        self.mean = opt['mean'] if 'mean' in opt else None
+        self.std = opt['std'] if 'std' in opt else None
+
+
+        # data_list = []
+        self.gts = None
+        self.lqs = None
+
+        self.dataroot_gt = opt['dataroot_gt']
+        self.dataroot_lq = opt['dataroot_lq']
+
+
+
+    def __getitem__(self, index):
+        if self.lqs is None:
+            # print('self.dataroot lq .. ', self.dataroot_lq, self.dataroot_gt)
+            with open(self.dataroot_lq, 'rb') as f:
+                self.lqs = pickle.load(f)
+        if self.gts is None:
+            with open(self.dataroot_gt, 'rb') as f:
+                self.gts = pickle.load(f)
+            # with open(opt['dataroot_gt'], 'rb') as f:
+            #     self.gts = pickle.load(f)
+
+
+
+        index = index % len(self.lqs)
+
+        scale = self.opt['scale']
+
+        # lr_id, hr_id = self.data_list[index]
+        #
+        # # print('lr_id, hr_id .. ', lr_id, hr_id)
+        #
+        # try:
+        #     img_lr = np.frombuffer(self.fetcher.get(lr_id), np.uint8)
+        #     img_hr = np.frombuffer(self.fetcher.get(hr_id), np.uint8)
+        # except:
+        #     import time
+        #     # time.sleep(0.01)
+        #     # raise Exception(f'nori id..{index},{lr_id},{hr_id} not working .. ')
+        #     print(f'nori id..{index},{lr_id},{hr_id} not working .. ')
+        #     exit(0)
+        #     # return self.__getitem__(index)
+        #
+        #
+        # h, w, c = 480, 480, 6
+        #
+        # if img_hr.shape[0] != h * w * c:
+        #     print('index .. ', index, lr_id, hr_id, img_hr.shape, img_lr.shape)
+        #
+        # assert img_hr.shape[0] == h * w * c
+
+        img_lq = self.lqs[index].copy().astype(np.float32) / 255.
+        #
+        # print('index .. ', index)
+        # if index >= len(self.gts1):
+        #     index_gt = index - len(self.gts1)
+        #     img_gt = self.gts2[index_gt].copy().astype(np.float32) / 255.
+        # else:
+        #     index_gt = index
+        #     img_gt = self.gts1[index_gt].copy().astype(np.float32) / 255.
+        #
+        #
+        img_gt = self.gts[index].copy().astype(np.float32) / 255.
+
+        # img_lr = img_lr.reshape(h // 4, w // 4, c).astype(np.float32) / 255.
+        # img_hr = img_hr.reshape(h, w, c).astype(np.float32) / 255.
+
+        # img_lr, img_hr = img_lr.copy(), img_hr.copy()
+
+
+        # Load gt and lq images. Dimension order: HWC; channel order: BGR;
+        # image range: [0, 1], float32.
+        # gt_path = self.paths[index]['gt_path']
+
+        # gt_path_L = os.path.join(self.gt_folder, '{:04}_L.png'.format(index + 1))
+        # gt_path_R = os.path.join(self.gt_folder, '{:04}_R.png'.format(index + 1))
+
+
+        # print('gt path,', gt_path)
+        # img_bytes = self.file_client.get(gt_path_L, 'gt')
+        # try:
+        #     img_gt_L = imfrombytes(img_bytes, float32=True)
+        # except:
+        #     raise Exception("gt path {} not working".format(gt_path_L))
+        #
+        # img_bytes = self.file_client.get(gt_path_R, 'gt')
+        # try:
+        #     img_gt_R = imfrombytes(img_bytes, float32=True)
+        # except:
+        #     raise Exception("gt path {} not working".format(gt_path_R))
+
+
+        # lq_path_L = os.path.join(self.lq_folder, '{:04}_L.png'.format(index + 1))
+        # lq_path_R = os.path.join(self.lq_folder, '{:04}_R.png'.format(index + 1))
+
+        # lq_path = self.paths[index]['lq_path']
+        # print(', lq path', lq_path)
+        # img_bytes = self.file_client.get(lq_path_L, 'lq')
+        # try:
+        #     img_lq_L = imfrombytes(img_bytes, float32=True)
+        # except:
+        #     raise Exception("lq path {} not working".format(lq_path_L))
+
+        # img_bytes = self.file_client.get(lq_path_R, 'lq')
+        # try:
+        #     img_lq_R = imfrombytes(img_bytes, float32=True)
+        # except:
+        #     raise Exception("lq path {} not working".format(lq_path_R))
+
+
+
+        # img_gt = np.concatenate([img_gt_L, img_gt_R], axis=-1)
+        # img_lq = np.concatenate([img_lq_L, img_lq_R], axis=-1)
+
+        # img_gt = img_hr.copy()
+        # img_lq = img_lr.copy()
+
+        # augmentation for training
+        rot90 = False
+
+        if self.opt['phase'] == 'train':
+            if 'gt_size_h' in self.opt and 'gt_size_w' in self.opt:
+                gt_size_h = int(self.opt['gt_size_h'])
+                gt_size_w = int(self.opt['gt_size_w'])
+            else:
+                gt_size = int(self.opt['gt_size'])
+                gt_size_h, gt_size_w = gt_size, gt_size
+
+
+            if 'flip_LR' in self.opt and self.opt['flip_LR']:
+                if np.random.rand() < 0.5:
+                    img_gt = img_gt[:, :, [3, 4, 5, 0, 1, 2]]
+                    img_lq = img_lq[:, :, [3, 4, 5, 0, 1, 2]]
+
+                    # img_gt, img_lq
+
+            if 'flip_RGB' in self.opt and self.opt['flip_RGB']:
+                idx = [
+                    [0, 1, 2, 3, 4, 5],
+                    [0, 2, 1, 3, 5, 4],
+                    [1, 0, 2, 4, 3, 5],
+                    [1, 2, 0, 4, 5, 3],
+                    [2, 0, 1, 5, 3, 4],
+                    [2, 1, 0, 5, 4, 3],
+                ][int(np.random.rand() * 6)]
+
+                img_gt = img_gt[:, :, idx]
+                img_lq = img_lq[:, :, idx]
+
+            if 'inverse_RGB' in self.opt and self.opt['inverse_RGB']:
+                for i in range(3):
+                    if np.random.rand() < 0.5:
+                        img_gt[:, :, i] = 1 - img_gt[:, :, i]
+                        img_gt[:, :, i+3] = 1 - img_gt[:, :, i+3]
+                        img_lq[:, :, i] = 1 - img_lq[:, :, i]
+                        img_lq[:, :, i+3] = 1 - img_lq[:, :, i+3]
+
+            if 'naive_inverse_RGB' in self.opt and self.opt['naive_inverse_RGB']:
+                # for i in range(3):
+                if np.random.rand() < 0.5:
+                    img_gt = 1 - img_gt
+                    img_lq = 1 - img_lq
+                    # img_gt[:, :, i] = 1 - img_gt[:, :, i]
+                    # img_gt[:, :, i+3] = 1 - img_gt[:, :, i+3]
+                    # img_lq[:, :, i] = 1 - img_lq[:, :, i]
+                    # img_lq[:, :, i+3] = 1 - img_lq[:, :, i+3]
+
+            if 'random_offset' in self.opt and self.opt['random_offset'] > 0:
+                # if np.random.rand() < 0.9:
+                S = int(self.opt['random_offset'])
+
+                offsets = int(np.random.rand() * (S+1))  #1~S
+                s2, s4 = 0, 0
+
+                if np.random.rand() < 0.5:
+                    s2 = offsets
+                else:
+                    s4 = offsets
+
+                _, w, _ = img_lq.shape
+
+                img_lq = np.concatenate([img_lq[:, s2:w-s4, :3], img_lq[:, s4:w-s2, 3:]], axis=-1)
+                img_gt = np.concatenate(
+                    [img_gt[:, 4 * s2:4*w-4 * s4, :3], img_gt[:, 4 * s4:4*w-4 * s2, 3:]], axis=-1)
+
+            # random crop
+            img_gt, img_lq = img_gt.copy(), img_lq.copy()
+            img_gt, img_lq = paired_random_crop_hw(img_gt, img_lq, gt_size_h, gt_size_w, scale,
+                                                'gt_path_L_and_R')
+            # flip, rotation
+            imgs, status = augment([img_gt, img_lq], self.opt['use_hflip'],
+                                    self.opt['use_rot'], vflip=self.opt['use_vflip'], return_status=True)
+
+
+            img_gt, img_lq = imgs
+            hflip, vflip, rot90 = status
+
+        # if self.opt['phase'] == 'train':
+        #     gt_size = self.opt['gt_size']
+        #     # padding
+        #     img_gt, img_lq = padding(img_gt, img_lq, gt_size)
+        #
+        #     # random crop
+        #     img_gt, img_lq = paired_random_crop(img_gt, img_lq, gt_size, scale,
+        #                                         'gt_path_L_and_R')
+        #     # flip, rotation
+        #     img_gt, img_lq = augment([img_gt, img_lq], self.opt['use_hflip'],
+        #                              self.opt['use_rot'], vflip=self.opt['use_vflip'])
+
+        # TODO: color space transform
+        # BGR to RGB, HWC to CHW, numpy to tensor
+        img_gt, img_lq = img2tensor([img_gt, img_lq],
+                                    bgr2rgb=True,
+                                    float32=True)
+        # normalize
+        if self.mean is not None or self.std is not None:
+            normalize(img_lq, self.mean, self.std, inplace=True)
+            normalize(img_gt, self.mean, self.std, inplace=True)
+
+        # if scale != 1:
+        #     c, h, w = img_lq.shape
+        #     img_lq = resize(img_lq, [h*scale, w*scale])
+            # print('img_lq .. ', img_lq.shape, img_gt.shape)
+
+        return {
+            'lq': img_lq,
+            'gt': img_gt,
+            'lq_path': 'lq path ',
+            'gt_path': 'gt path ',
+            'is_rot': 1. if rot90 else 0.
+        }
+
+    def __len__(self):
+        return 3200005
+        # return 1000
+        # return len(self.lqs)
+        # return len(self.paths)

NAFNet/basicsr/data/paired_image_SR_LR_dataset.py

@@ -0,0 +1,301 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+from torch.utils import data as data
+from torchvision.transforms.functional import normalize, resize
+
+from basicsr.data.data_util import (paired_paths_from_folder,
+                                    paired_paths_from_lmdb,
+                                    paired_paths_from_meta_info_file)
+from basicsr.data.transforms import augment, paired_random_crop, paired_random_crop_hw
+from basicsr.utils import FileClient, imfrombytes, img2tensor, padding
+import os
+import numpy as np
+
+class PairedImageSRLRDataset(data.Dataset):
+    """Paired image dataset for image restoration.
+
+    Read LQ (Low Quality, e.g. LR (Low Resolution), blurry, noisy, etc) and
+    GT image pairs.
+
+    There are three modes:
+    1. 'lmdb': Use lmdb files.
+        If opt['io_backend'] == lmdb.
+    2. 'meta_info_file': Use meta information file to generate paths.
+        If opt['io_backend'] != lmdb and opt['meta_info_file'] is not None.
+    3. 'folder': Scan folders to generate paths.
+        The rest.
+
+    Args:
+        opt (dict): Config for train datasets. It contains the following keys:
+            dataroot_gt (str): Data root path for gt.
+            dataroot_lq (str): Data root path for lq.
+            meta_info_file (str): Path for meta information file.
+            io_backend (dict): IO backend type and other kwarg.
+            filename_tmpl (str): Template for each filename. Note that the
+                template excludes the file extension. Default: '{}'.
+            gt_size (int): Cropped patched size for gt patches.
+            use_flip (bool): Use horizontal flips.
+            use_rot (bool): Use rotation (use vertical flip and transposing h
+                and w for implementation).
+
+            scale (bool): Scale, which will be added automatically.
+            phase (str): 'train' or 'val'.
+    """
+
+    def __init__(self, opt):
+        super(PairedImageSRLRDataset, self).__init__()
+        self.opt = opt
+        # file client (io backend)
+        self.file_client = None
+        self.io_backend_opt = opt['io_backend']
+        self.mean = opt['mean'] if 'mean' in opt else None
+        self.std = opt['std'] if 'std' in opt else None
+
+        self.gt_folder, self.lq_folder = opt['dataroot_gt'], opt['dataroot_lq']
+        if 'filename_tmpl' in opt:
+            self.filename_tmpl = opt['filename_tmpl']
+        else:
+            self.filename_tmpl = '{}'
+
+        if self.io_backend_opt['type'] == 'lmdb':
+            self.io_backend_opt['db_paths'] = [self.lq_folder, self.gt_folder]
+            self.io_backend_opt['client_keys'] = ['lq', 'gt']
+            self.paths = paired_paths_from_lmdb(
+                [self.lq_folder, self.gt_folder], ['lq', 'gt'])
+        elif 'meta_info_file' in self.opt and self.opt[
+                'meta_info_file'] is not None:
+            self.paths = paired_paths_from_meta_info_file(
+                [self.lq_folder, self.gt_folder], ['lq', 'gt'],
+                self.opt['meta_info_file'], self.filename_tmpl)
+        else:
+            import os
+            nums_lq = len(os.listdir(self.lq_folder))
+            nums_gt = len(os.listdir(self.gt_folder))
+
+            # nums_lq = sorted(nums_lq)
+            # nums_gt = sorted(nums_gt)
+
+            # print('lq gt ... opt')
+            # print(nums_lq, nums_gt, opt)
+            assert nums_gt == nums_lq
+
+            self.nums = nums_lq
+            # {:04}_L   {:04}_R
+
+
+            # self.paths = paired_paths_from_folder(
+            #     [self.lq_folder, self.gt_folder], ['lq', 'gt'],
+            #     self.filename_tmpl)
+
+    def __getitem__(self, index):
+        if self.file_client is None:
+            self.file_client = FileClient(
+                self.io_backend_opt.pop('type'), **self.io_backend_opt)
+
+        scale = self.opt['scale']
+
+        # Load gt and lq images. Dimension order: HWC; channel order: BGR;
+        # image range: [0, 1], float32.
+        # gt_path = self.paths[index]['gt_path']
+
+        gt_path_L = os.path.join(self.gt_folder, '{:04}_L.png'.format(index + 1))
+        gt_path_R = os.path.join(self.gt_folder, '{:04}_R.png'.format(index + 1))
+
+
+        # print('gt path,', gt_path)
+        img_bytes = self.file_client.get(gt_path_L, 'gt')
+        try:
+            img_gt_L = imfrombytes(img_bytes, float32=True)
+        except:
+            raise Exception("gt path {} not working".format(gt_path_L))
+
+        img_bytes = self.file_client.get(gt_path_R, 'gt')
+        try:
+            img_gt_R = imfrombytes(img_bytes, float32=True)
+        except:
+            raise Exception("gt path {} not working".format(gt_path_R))
+
+
+        lq_path_L = os.path.join(self.lq_folder, '{:04}_L.png'.format(index + 1))
+        lq_path_R = os.path.join(self.lq_folder, '{:04}_R.png'.format(index + 1))
+
+        # lq_path = self.paths[index]['lq_path']
+        # print(', lq path', lq_path)
+        img_bytes = self.file_client.get(lq_path_L, 'lq')
+        try:
+            img_lq_L = imfrombytes(img_bytes, float32=True)
+        except:
+            raise Exception("lq path {} not working".format(lq_path_L))
+
+        img_bytes = self.file_client.get(lq_path_R, 'lq')
+        try:
+            img_lq_R = imfrombytes(img_bytes, float32=True)
+        except:
+            raise Exception("lq path {} not working".format(lq_path_R))
+
+
+
+        img_gt = np.concatenate([img_gt_L, img_gt_R], axis=-1)
+        img_lq = np.concatenate([img_lq_L, img_lq_R], axis=-1)
+
+        # augmentation for training
+        if self.opt['phase'] == 'train':
+            gt_size = self.opt['gt_size']
+            # padding
+            img_gt, img_lq = padding(img_gt, img_lq, gt_size)
+
+            # random crop
+            img_gt, img_lq = paired_random_crop(img_gt, img_lq, gt_size, scale,
+                                                gt_path_L)
+            # flip, rotation
+            img_gt, img_lq = augment([img_gt, img_lq], self.opt['use_flip'],
+                                     self.opt['use_rot'])
+
+        # TODO: color space transform
+        # BGR to RGB, HWC to CHW, numpy to tensor
+        img_gt, img_lq = img2tensor([img_gt, img_lq],
+                                    bgr2rgb=True,
+                                    float32=True)
+        # normalize
+        if self.mean is not None or self.std is not None:
+            normalize(img_lq, self.mean, self.std, inplace=True)
+            normalize(img_gt, self.mean, self.std, inplace=True)
+
+        # if scale != 1:
+        #     c, h, w = img_lq.shape
+        #     img_lq = resize(img_lq, [h*scale, w*scale])
+            # print('img_lq .. ', img_lq.shape, img_gt.shape)
+
+
+        return {
+            'lq': img_lq,
+            'gt': img_gt,
+            'lq_path': f'{index+1:04}',
+            'gt_path': f'{index+1:04}',
+        }
+
+    def __len__(self):
+        return self.nums // 2
+
+
+class PairedStereoImageDataset(data.Dataset):
+    '''
+    Paired dataset for stereo SR (Flickr1024, KITTI, Middlebury)
+    '''
+    def __init__(self, opt):
+        super(PairedStereoImageDataset, self).__init__()
+        self.opt = opt
+        # file client (io backend)
+        self.file_client = None
+        self.io_backend_opt = opt['io_backend']
+        self.mean = opt['mean'] if 'mean' in opt else None
+        self.std = opt['std'] if 'std' in opt else None
+
+        self.gt_folder, self.lq_folder = opt['dataroot_gt'], opt['dataroot_lq']
+        if 'filename_tmpl' in opt:
+            self.filename_tmpl = opt['filename_tmpl']
+        else:
+            self.filename_tmpl = '{}'
+
+        assert self.io_backend_opt['type'] == 'disk'
+        import os
+        self.lq_files = os.listdir(self.lq_folder)
+        self.gt_files = os.listdir(self.gt_folder)
+
+        self.nums = len(self.gt_files)
+
+    def __getitem__(self, index):
+        if self.file_client is None:
+            self.file_client = FileClient(
+                self.io_backend_opt.pop('type'), **self.io_backend_opt)
+
+        gt_path_L = os.path.join(self.gt_folder, self.gt_files[index], 'hr0.png')
+        gt_path_R = os.path.join(self.gt_folder, self.gt_files[index], 'hr1.png')
+
+        img_bytes = self.file_client.get(gt_path_L, 'gt')
+        try:
+            img_gt_L = imfrombytes(img_bytes, float32=True)
+        except:
+            raise Exception("gt path {} not working".format(gt_path_L))
+
+        img_bytes = self.file_client.get(gt_path_R, 'gt')
+        try:
+            img_gt_R = imfrombytes(img_bytes, float32=True)
+        except:
+            raise Exception("gt path {} not working".format(gt_path_R))
+
+        lq_path_L = os.path.join(self.lq_folder, self.lq_files[index], 'lr0.png')
+        lq_path_R = os.path.join(self.lq_folder, self.lq_files[index], 'lr1.png')
+
+        # lq_path = self.paths[index]['lq_path']
+        # print(', lq path', lq_path)
+        img_bytes = self.file_client.get(lq_path_L, 'lq')
+        try:
+            img_lq_L = imfrombytes(img_bytes, float32=True)
+        except:
+            raise Exception("lq path {} not working".format(lq_path_L))
+
+        img_bytes = self.file_client.get(lq_path_R, 'lq')
+        try:
+            img_lq_R = imfrombytes(img_bytes, float32=True)
+        except:
+            raise Exception("lq path {} not working".format(lq_path_R))
+
+        img_gt = np.concatenate([img_gt_L, img_gt_R], axis=-1)
+        img_lq = np.concatenate([img_lq_L, img_lq_R], axis=-1)
+
+        scale = self.opt['scale']
+        # augmentation for training
+        if self.opt['phase'] == 'train':
+            if 'gt_size_h' in self.opt and 'gt_size_w' in self.opt:
+                gt_size_h = int(self.opt['gt_size_h'])
+                gt_size_w = int(self.opt['gt_size_w'])
+            else:
+                gt_size = int(self.opt['gt_size'])
+                gt_size_h, gt_size_w = gt_size, gt_size
+
+            if 'flip_RGB' in self.opt and self.opt['flip_RGB']:
+                idx = [
+                    [0, 1, 2, 3, 4, 5],
+                    [0, 2, 1, 3, 5, 4],
+                    [1, 0, 2, 4, 3, 5],
+                    [1, 2, 0, 4, 5, 3],
+                    [2, 0, 1, 5, 3, 4],
+                    [2, 1, 0, 5, 4, 3],
+                ][int(np.random.rand() * 6)]
+
+                img_gt = img_gt[:, :, idx]
+                img_lq = img_lq[:, :, idx]
+
+            # random crop
+            img_gt, img_lq = img_gt.copy(), img_lq.copy()
+            img_gt, img_lq = paired_random_crop_hw(img_gt, img_lq, gt_size_h, gt_size_w, scale,
+                                                'gt_path_L_and_R')
+            # flip, rotation
+            imgs, status = augment([img_gt, img_lq], self.opt['use_hflip'],
+                                    self.opt['use_rot'], vflip=self.opt['use_vflip'], return_status=True)
+
+
+            img_gt, img_lq = imgs
+
+        img_gt, img_lq = img2tensor([img_gt, img_lq],
+                                    bgr2rgb=True,
+                                    float32=True)
+        # normalize
+        if self.mean is not None or self.std is not None:
+            normalize(img_lq, self.mean, self.std, inplace=True)
+            normalize(img_gt, self.mean, self.std, inplace=True)
+
+        return {
+            'lq': img_lq,
+            'gt': img_gt,
+            'lq_path': os.path.join(self.lq_folder, self.lq_files[index]),
+            'gt_path': os.path.join(self.gt_folder, self.gt_files[index]),
+        }
+
+    def __len__(self):
+        return self.nums

NAFNet/basicsr/data/paired_image_dataset.py

@@ -0,0 +1,135 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+from torch.utils import data as data
+from torchvision.transforms.functional import normalize
+
+from basicsr.data.data_util import (paired_paths_from_folder,
+                                    paired_paths_from_lmdb,
+                                    paired_paths_from_meta_info_file)
+from basicsr.data.transforms import augment, paired_random_crop
+from basicsr.utils import FileClient, imfrombytes, img2tensor, padding
+
+
+class PairedImageDataset(data.Dataset):
+    """Paired image dataset for image restoration.
+
+    Read LQ (Low Quality, e.g. LR (Low Resolution), blurry, noisy, etc) and
+    GT image pairs.
+
+    There are three modes:
+    1. 'lmdb': Use lmdb files.
+        If opt['io_backend'] == lmdb.
+    2. 'meta_info_file': Use meta information file to generate paths.
+        If opt['io_backend'] != lmdb and opt['meta_info_file'] is not None.
+    3. 'folder': Scan folders to generate paths.
+        The rest.
+
+    Args:
+        opt (dict): Config for train datasets. It contains the following keys:
+            dataroot_gt (str): Data root path for gt.
+            dataroot_lq (str): Data root path for lq.
+            meta_info_file (str): Path for meta information file.
+            io_backend (dict): IO backend type and other kwarg.
+            filename_tmpl (str): Template for each filename. Note that the
+                template excludes the file extension. Default: '{}'.
+            gt_size (int): Cropped patched size for gt patches.
+            use_flip (bool): Use horizontal flips.
+            use_rot (bool): Use rotation (use vertical flip and transposing h
+                and w for implementation).
+
+            scale (bool): Scale, which will be added automatically.
+            phase (str): 'train' or 'val'.
+    """
+
+    def __init__(self, opt):
+        super(PairedImageDataset, self).__init__()
+        self.opt = opt
+        # file client (io backend)
+        self.file_client = None
+        self.io_backend_opt = opt['io_backend']
+        self.mean = opt['mean'] if 'mean' in opt else None
+        self.std = opt['std'] if 'std' in opt else None
+
+        self.gt_folder, self.lq_folder = opt['dataroot_gt'], opt['dataroot_lq']
+        if 'filename_tmpl' in opt:
+            self.filename_tmpl = opt['filename_tmpl']
+        else:
+            self.filename_tmpl = '{}'
+
+        if self.io_backend_opt['type'] == 'lmdb':
+            self.io_backend_opt['db_paths'] = [self.lq_folder, self.gt_folder]
+            self.io_backend_opt['client_keys'] = ['lq', 'gt']
+            self.paths = paired_paths_from_lmdb(
+                [self.lq_folder, self.gt_folder], ['lq', 'gt'])
+        elif 'meta_info_file' in self.opt and self.opt[
+                'meta_info_file'] is not None:
+            self.paths = paired_paths_from_meta_info_file(
+                [self.lq_folder, self.gt_folder], ['lq', 'gt'],
+                self.opt['meta_info_file'], self.filename_tmpl)
+        else:
+            self.paths = paired_paths_from_folder(
+                [self.lq_folder, self.gt_folder], ['lq', 'gt'],
+                self.filename_tmpl)
+
+    def __getitem__(self, index):
+        if self.file_client is None:
+            self.file_client = FileClient(
+                self.io_backend_opt.pop('type'), **self.io_backend_opt)
+
+        scale = self.opt['scale']
+
+        # Load gt and lq images. Dimension order: HWC; channel order: BGR;
+        # image range: [0, 1], float32.
+        gt_path = self.paths[index]['gt_path']
+        # print('gt path,', gt_path)
+        img_bytes = self.file_client.get(gt_path, 'gt')
+        try:
+            img_gt = imfrombytes(img_bytes, float32=True)
+        except:
+            raise Exception("gt path {} not working".format(gt_path))
+
+        lq_path = self.paths[index]['lq_path']
+        # print(', lq path', lq_path)
+        img_bytes = self.file_client.get(lq_path, 'lq')
+        try:
+            img_lq = imfrombytes(img_bytes, float32=True)
+        except:
+            raise Exception("lq path {} not working".format(lq_path))
+
+
+        # augmentation for training
+        if self.opt['phase'] == 'train':
+            gt_size = self.opt['gt_size']
+            # padding
+            img_gt, img_lq = padding(img_gt, img_lq, gt_size)
+
+            # random crop
+            img_gt, img_lq = paired_random_crop(img_gt, img_lq, gt_size, scale,
+                                                gt_path)
+            # flip, rotation
+            img_gt, img_lq = augment([img_gt, img_lq], self.opt['use_flip'],
+                                     self.opt['use_rot'])
+
+        # TODO: color space transform
+        # BGR to RGB, HWC to CHW, numpy to tensor
+        img_gt, img_lq = img2tensor([img_gt, img_lq],
+                                    bgr2rgb=True,
+                                    float32=True)
+        # normalize
+        if self.mean is not None or self.std is not None:
+            normalize(img_lq, self.mean, self.std, inplace=True)
+            normalize(img_gt, self.mean, self.std, inplace=True)
+
+        return {
+            'lq': img_lq,
+            'gt': img_gt,
+            'lq_path': lq_path,
+            'gt_path': gt_path
+        }
+
+    def __len__(self):
+        return len(self.paths)

NAFNet/basicsr/data/prefetch_dataloader.py

@@ -0,0 +1,132 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+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()

NAFNet/basicsr/data/reds_dataset.py

@@ -0,0 +1,243 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+import numpy as np
+import random
+import torch
+from pathlib import Path
+from torch.utils import data as data
+
+from basicsr.data.transforms import augment, paired_random_crop
+from basicsr.utils import FileClient, get_root_logger, imfrombytes, img2tensor
+from basicsr.utils.flow_util import dequantize_flow
+
+
+class REDSDataset(data.Dataset):
+    """REDS dataset for training.
+
+    The keys are generated from a meta info txt file.
+    basicsr/data/meta_info/meta_info_REDS_GT.txt
+
+    Each line contains:
+    1. subfolder (clip) name; 2. frame number; 3. image shape, seperated by
+    a white space.
+    Examples:
+    000 100 (720,1280,3)
+    001 100 (720,1280,3)
+    ...
+
+    Key examples: "000/00000000"
+    GT (gt): Ground-Truth;
+    LQ (lq): Low-Quality, e.g., low-resolution/blurry/noisy/compressed frames.
+
+    Args:
+        opt (dict): Config for train dataset. It contains the following keys:
+            dataroot_gt (str): Data root path for gt.
+            dataroot_lq (str): Data root path for lq.
+            dataroot_flow (str, optional): Data root path for flow.
+            meta_info_file (str): Path for meta information file.
+            val_partition (str): Validation partition types. 'REDS4' or
+                'official'.
+            io_backend (dict): IO backend type and other kwarg.
+
+            num_frame (int): Window size for input frames.
+            gt_size (int): Cropped patched size for gt patches.
+            interval_list (list): Interval list for temporal augmentation.
+            random_reverse (bool): Random reverse input frames.
+            use_flip (bool): Use horizontal flips.
+            use_rot (bool): Use rotation (use vertical flip and transposing h
+                and w for implementation).
+
+            scale (bool): Scale, which will be added automatically.
+    """
+
+    def __init__(self, opt):
+        super(REDSDataset, self).__init__()
+        self.opt = opt
+        self.gt_root, self.lq_root = Path(opt['dataroot_gt']), Path(
+            opt['dataroot_lq'])
+        self.flow_root = Path(
+            opt['dataroot_flow']) if opt['dataroot_flow'] is not None else None
+        assert opt['num_frame'] % 2 == 1, (
+            f'num_frame should be odd number, but got {opt["num_frame"]}')
+        self.num_frame = opt['num_frame']
+        self.num_half_frames = opt['num_frame'] // 2
+
+        self.keys = []
+        with open(opt['meta_info_file'], 'r') as fin:
+            for line in fin:
+                folder, frame_num, _ = line.split(' ')
+                self.keys.extend(
+                    [f'{folder}/{i:08d}' for i in range(int(frame_num))])
+
+        # remove the video clips used in validation
+        if opt['val_partition'] == 'REDS4':
+            val_partition = ['000', '011', '015', '020']
+        elif opt['val_partition'] == 'official':
+            val_partition = [f'{v:03d}' for v in range(240, 270)]
+        else:
+            raise ValueError(
+                f'Wrong validation partition {opt["val_partition"]}.'
+                f"Supported ones are ['official', 'REDS4'].")
+        self.keys = [
+            v for v in self.keys if v.split('/')[0] not in val_partition
+        ]
+
+        # file client (io backend)
+        self.file_client = None
+        self.io_backend_opt = opt['io_backend']
+        self.is_lmdb = False
+        if self.io_backend_opt['type'] == 'lmdb':
+            self.is_lmdb = True
+            if self.flow_root is not None:
+                self.io_backend_opt['db_paths'] = [
+                    self.lq_root, self.gt_root, self.flow_root
+                ]
+                self.io_backend_opt['client_keys'] = ['lq', 'gt', 'flow']
+            else:
+                self.io_backend_opt['db_paths'] = [self.lq_root, self.gt_root]
+                self.io_backend_opt['client_keys'] = ['lq', 'gt']
+
+        # temporal augmentation configs
+        self.interval_list = opt['interval_list']
+        self.random_reverse = opt['random_reverse']
+        interval_str = ','.join(str(x) for x in opt['interval_list'])
+        logger = get_root_logger()
+        logger.info(f'Temporal augmentation interval list: [{interval_str}]; '
+                    f'random reverse is {self.random_reverse}.')
+
+    def __getitem__(self, index):
+        if self.file_client is None:
+            self.file_client = FileClient(
+                self.io_backend_opt.pop('type'), **self.io_backend_opt)
+
+        scale = self.opt['scale']
+        gt_size = self.opt['gt_size']
+        key = self.keys[index]
+        clip_name, frame_name = key.split('/')  # key example: 000/00000000
+        center_frame_idx = int(frame_name)
+
+        # determine the neighboring frames
+        interval = random.choice(self.interval_list)
+
+        # ensure not exceeding the borders
+        start_frame_idx = center_frame_idx - self.num_half_frames * interval
+        end_frame_idx = center_frame_idx + self.num_half_frames * interval
+        # each clip has 100 frames starting from 0 to 99
+        while (start_frame_idx < 0) or (end_frame_idx > 99):
+            center_frame_idx = random.randint(0, 99)
+            start_frame_idx = (
+                center_frame_idx - self.num_half_frames * interval)
+            end_frame_idx = center_frame_idx + self.num_half_frames * interval
+        frame_name = f'{center_frame_idx:08d}'
+        neighbor_list = list(
+            range(center_frame_idx - self.num_half_frames * interval,
+                  center_frame_idx + self.num_half_frames * interval + 1,
+                  interval))
+        # random reverse
+        if self.random_reverse and random.random() < 0.5:
+            neighbor_list.reverse()
+
+        assert len(neighbor_list) == self.num_frame, (
+            f'Wrong length of neighbor list: {len(neighbor_list)}')
+
+        # get the GT frame (as the center frame)
+        if self.is_lmdb:
+            img_gt_path = f'{clip_name}/{frame_name}'
+        else:
+            img_gt_path = self.gt_root / clip_name / f'{frame_name}.png'
+        img_bytes = self.file_client.get(img_gt_path, 'gt')
+        img_gt = imfrombytes(img_bytes, float32=True)
+
+        # get the neighboring LQ frames
+        img_lqs = []
+        for neighbor in neighbor_list:
+            if self.is_lmdb:
+                img_lq_path = f'{clip_name}/{neighbor:08d}'
+            else:
+                img_lq_path = self.lq_root / clip_name / f'{neighbor:08d}.png'
+            img_bytes = self.file_client.get(img_lq_path, 'lq')
+            img_lq = imfrombytes(img_bytes, float32=True)
+            img_lqs.append(img_lq)
+
+        # get flows
+        if self.flow_root is not None:
+            img_flows = []
+            # read previous flows
+            for i in range(self.num_half_frames, 0, -1):
+                if self.is_lmdb:
+                    flow_path = f'{clip_name}/{frame_name}_p{i}'
+                else:
+                    flow_path = (
+                        self.flow_root / clip_name / f'{frame_name}_p{i}.png')
+                img_bytes = self.file_client.get(flow_path, 'flow')
+                cat_flow = imfrombytes(
+                    img_bytes, flag='grayscale',
+                    float32=False)  # uint8, [0, 255]
+                dx, dy = np.split(cat_flow, 2, axis=0)
+                flow = dequantize_flow(
+                    dx, dy, max_val=20,
+                    denorm=False)  # we use max_val 20 here.
+                img_flows.append(flow)
+            # read next flows
+            for i in range(1, self.num_half_frames + 1):
+                if self.is_lmdb:
+                    flow_path = f'{clip_name}/{frame_name}_n{i}'
+                else:
+                    flow_path = (
+                        self.flow_root / clip_name / f'{frame_name}_n{i}.png')
+                img_bytes = self.file_client.get(flow_path, 'flow')
+                cat_flow = imfrombytes(
+                    img_bytes, flag='grayscale',
+                    float32=False)  # uint8, [0, 255]
+                dx, dy = np.split(cat_flow, 2, axis=0)
+                flow = dequantize_flow(
+                    dx, dy, max_val=20,
+                    denorm=False)  # we use max_val 20 here.
+                img_flows.append(flow)
+
+            # for random crop, here, img_flows and img_lqs have the same
+            # spatial size
+            img_lqs.extend(img_flows)
+
+        # randomly crop
+        img_gt, img_lqs = paired_random_crop(img_gt, img_lqs, gt_size, scale,
+                                             img_gt_path)
+        if self.flow_root is not None:
+            img_lqs, img_flows = img_lqs[:self.num_frame], img_lqs[self.
+                                                                   num_frame:]
+
+        # augmentation - flip, rotate
+        img_lqs.append(img_gt)
+        if self.flow_root is not None:
+            img_results, img_flows = augment(img_lqs, self.opt['use_flip'],
+                                             self.opt['use_rot'], img_flows)
+        else:
+            img_results = augment(img_lqs, self.opt['use_flip'],
+                                  self.opt['use_rot'])
+
+        img_results = img2tensor(img_results)
+        img_lqs = torch.stack(img_results[0:-1], dim=0)
+        img_gt = img_results[-1]
+
+        if self.flow_root is not None:
+            img_flows = img2tensor(img_flows)
+            # add the zero center flow
+            img_flows.insert(self.num_half_frames,
+                             torch.zeros_like(img_flows[0]))
+            img_flows = torch.stack(img_flows, dim=0)
+
+        # img_lqs: (t, c, h, w)
+        # img_flows: (t, 2, h, w)
+        # img_gt: (c, h, w)
+        # key: str
+        if self.flow_root is not None:
+            return {'lq': img_lqs, 'flow': img_flows, 'gt': img_gt, 'key': key}
+        else:
+            return {'lq': img_lqs, 'gt': img_gt, 'key': key}
+
+    def __len__(self):
+        return len(self.keys)

NAFNet/basicsr/data/single_image_dataset.py

@@ -0,0 +1,73 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+from os import path as osp
+from torch.utils import data as data
+from torchvision.transforms.functional import normalize
+
+from basicsr.data.data_util import paths_from_lmdb
+from basicsr.utils import FileClient, imfrombytes, img2tensor, scandir
+
+
+class SingleImageDataset(data.Dataset):
+    """Read only lq images in the test phase.
+
+    Read LQ (Low Quality, e.g. LR (Low Resolution), blurry, noisy, etc).
+
+    There are two modes:
+    1. 'meta_info_file': Use meta information file to generate paths.
+    2. 'folder': Scan folders to generate paths.
+
+    Args:
+        opt (dict): Config for train datasets. It contains the following keys:
+            dataroot_lq (str): Data root path for lq.
+            meta_info_file (str): Path for meta information file.
+            io_backend (dict): IO backend type and other kwarg.
+    """
+
+    def __init__(self, opt):
+        super(SingleImageDataset, self).__init__()
+        self.opt = opt
+        # file client (io backend)
+        self.file_client = None
+        self.io_backend_opt = opt['io_backend']
+        self.mean = opt['mean'] if 'mean' in opt else None
+        self.std = opt['std'] if 'std' in opt else None
+        self.lq_folder = opt['dataroot_lq']
+
+        if self.io_backend_opt['type'] == 'lmdb':
+            self.io_backend_opt['db_paths'] = [self.lq_folder]
+            self.io_backend_opt['client_keys'] = ['lq']
+            self.paths = paths_from_lmdb(self.lq_folder)
+        elif 'meta_info_file' in self.opt:
+            with open(self.opt['meta_info_file'], 'r') as fin:
+                self.paths = [
+                    osp.join(self.lq_folder,
+                             line.split(' ')[0]) for line in fin
+                ]
+        else:
+            self.paths = sorted(list(scandir(self.lq_folder, full_path=True)))
+
+    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 lq image
+        lq_path = self.paths[index]
+        img_bytes = self.file_client.get(lq_path, 'lq')
+        img_lq = imfrombytes(img_bytes, float32=True)
+
+        # TODO: color space transform
+        # BGR to RGB, HWC to CHW, numpy to tensor
+        img_lq = img2tensor(img_lq, bgr2rgb=True, float32=True)
+        # normalize
+        if self.mean is not None or self.std is not None:
+            normalize(img_lq, self.mean, self.std, inplace=True)
+        return {'lq': img_lq, 'lq_path': lq_path}
+
+    def __len__(self):
+        return len(self.paths)

NAFNet/basicsr/data/transforms.py

@@ -0,0 +1,247 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+import cv2
+import random
+from cv2 import rotate
+import numpy as np
+
+
+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):
+    """Paired random crop.
+
+    It crops lists of lq and gt images with corresponding locations.
+
+    Args:
+        img_gts (list[ndarray] | ndarray): 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.
+
+    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]
+
+    h_lq, w_lq, _ = img_lqs[0].shape
+    h_gt, w_gt, _ = img_gts[0].shape
+    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
+    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)
+    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 paired_random_crop_hw(img_gts, img_lqs, gt_patch_size_h, gt_patch_size_w, scale, gt_path):
+    """Paired random crop.
+
+    It crops lists of lq and gt images with corresponding locations.
+
+    Args:
+        img_gts (list[ndarray] | ndarray): 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.
+
+    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]
+
+    h_lq, w_lq, _ = img_lqs[0].shape
+    h_gt, w_gt, _ = img_gts[0].shape
+    lq_patch_size_h = gt_patch_size_h // scale
+    lq_patch_size_w = gt_patch_size_w // 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_h)
+    left = random.randint(0, w_lq - lq_patch_size_w)
+
+    # crop lq patch
+    img_lqs = [
+        v[top:top + lq_patch_size_h, left:left + lq_patch_size_w, ...]
+        for v in img_lqs
+    ]
+
+    # crop corresponding gt patch
+    top_gt, left_gt = int(top * scale), int(left * scale)
+    img_gts = [
+        v[top_gt:top_gt + gt_patch_size_h, left_gt:left_gt + gt_patch_size_w, ...]
+        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, vflip=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
+    if vflip or rotation:
+        vflip = random.random() < 0.5
+    rot90 = rotation and random.random() < 0.5
+
+    def _augment(img):
+        if hflip:  # horizontal
+            cv2.flip(img, 1, img)
+            if img.shape[2] == 6:
+                img = img[:,:,[3,4,5,0,1,2]].copy() # swap left/right
+        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):
+    """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))
+    return rotated_img
+
+

NAFNet/basicsr/data/video_test_dataset.py

@@ -0,0 +1,331 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+import glob
+import torch
+from os import path as osp
+from torch.utils import data as data
+
+from basicsr.data.data_util import (duf_downsample, generate_frame_indices,
+                                    read_img_seq)
+from basicsr.utils import get_root_logger, scandir
+
+
+class VideoTestDataset(data.Dataset):
+    """Video test dataset.
+
+    Supported datasets: Vid4, REDS4, REDSofficial.
+    More generally, it supports testing dataset with following structures:
+
+    dataroot
+    ├── subfolder1
+        ├── frame000
+        ├── frame001
+        ├── ...
+    ├── subfolder1
+        ├── frame000
+        ├── frame001
+        ├── ...
+    ├── ...
+
+    For testing datasets, there is no need to prepare LMDB files.
+
+    Args:
+        opt (dict): Config for train dataset. It contains the following keys:
+            dataroot_gt (str): Data root path for gt.
+            dataroot_lq (str): Data root path for lq.
+            io_backend (dict): IO backend type and other kwarg.
+            cache_data (bool): Whether to cache testing datasets.
+            name (str): Dataset name.
+            meta_info_file (str): The path to the file storing the list of test
+                folders. If not provided, all the folders in the dataroot will
+                be used.
+            num_frame (int): Window size for input frames.
+            padding (str): Padding mode.
+    """
+
+    def __init__(self, opt):
+        super(VideoTestDataset, self).__init__()
+        self.opt = opt
+        self.cache_data = opt['cache_data']
+        self.gt_root, self.lq_root = opt['dataroot_gt'], opt['dataroot_lq']
+        self.data_info = {
+            'lq_path': [],
+            'gt_path': [],
+            'folder': [],
+            'idx': [],
+            'border': []
+        }
+        # file client (io backend)
+        self.file_client = None
+        self.io_backend_opt = opt['io_backend']
+        assert self.io_backend_opt[
+            'type'] != 'lmdb', 'No need to use lmdb during validation/test.'
+
+        logger = get_root_logger()
+        logger.info(f'Generate data info for VideoTestDataset - {opt["name"]}')
+        self.imgs_lq, self.imgs_gt = {}, {}
+        if 'meta_info_file' in opt:
+            with open(opt['meta_info_file'], 'r') as fin:
+                subfolders = [line.split(' ')[0] for line in fin]
+                subfolders_lq = [
+                    osp.join(self.lq_root, key) for key in subfolders
+                ]
+                subfolders_gt = [
+                    osp.join(self.gt_root, key) for key in subfolders
+                ]
+        else:
+            subfolders_lq = sorted(glob.glob(osp.join(self.lq_root, '*')))
+            subfolders_gt = sorted(glob.glob(osp.join(self.gt_root, '*')))
+
+        if opt['name'].lower() in ['vid4', 'reds4', 'redsofficial']:
+            for subfolder_lq, subfolder_gt in zip(subfolders_lq,
+                                                  subfolders_gt):
+                # get frame list for lq and gt
+                subfolder_name = osp.basename(subfolder_lq)
+                img_paths_lq = sorted(
+                    list(scandir(subfolder_lq, full_path=True)))
+                img_paths_gt = sorted(
+                    list(scandir(subfolder_gt, full_path=True)))
+
+                max_idx = len(img_paths_lq)
+                assert max_idx == len(img_paths_gt), (
+                    f'Different number of images in lq ({max_idx})'
+                    f' and gt folders ({len(img_paths_gt)})')
+
+                self.data_info['lq_path'].extend(img_paths_lq)
+                self.data_info['gt_path'].extend(img_paths_gt)
+                self.data_info['folder'].extend([subfolder_name] * max_idx)
+                for i in range(max_idx):
+                    self.data_info['idx'].append(f'{i}/{max_idx}')
+                border_l = [0] * max_idx
+                for i in range(self.opt['num_frame'] // 2):
+                    border_l[i] = 1
+                    border_l[max_idx - i - 1] = 1
+                self.data_info['border'].extend(border_l)
+
+                # cache data or save the frame list
+                if self.cache_data:
+                    logger.info(
+                        f'Cache {subfolder_name} for VideoTestDataset...')
+                    self.imgs_lq[subfolder_name] = read_img_seq(img_paths_lq)
+                    self.imgs_gt[subfolder_name] = read_img_seq(img_paths_gt)
+                else:
+                    self.imgs_lq[subfolder_name] = img_paths_lq
+                    self.imgs_gt[subfolder_name] = img_paths_gt
+        else:
+            raise ValueError(
+                f'Non-supported video test dataset: {type(opt["name"])}')
+
+    def __getitem__(self, index):
+        folder = self.data_info['folder'][index]
+        idx, max_idx = self.data_info['idx'][index].split('/')
+        idx, max_idx = int(idx), int(max_idx)
+        border = self.data_info['border'][index]
+        lq_path = self.data_info['lq_path'][index]
+
+        select_idx = generate_frame_indices(
+            idx, max_idx, self.opt['num_frame'], padding=self.opt['padding'])
+
+        if self.cache_data:
+            imgs_lq = self.imgs_lq[folder].index_select(
+                0, torch.LongTensor(select_idx))
+            img_gt = self.imgs_gt[folder][idx]
+        else:
+            img_paths_lq = [self.imgs_lq[folder][i] for i in select_idx]
+            imgs_lq = read_img_seq(img_paths_lq)
+            img_gt = read_img_seq([self.imgs_gt[folder][idx]])
+            img_gt.squeeze_(0)
+
+        return {
+            'lq': imgs_lq,  # (t, c, h, w)
+            'gt': img_gt,  # (c, h, w)
+            'folder': folder,  # folder name
+            'idx': self.data_info['idx'][index],  # e.g., 0/99
+            'border': border,  # 1 for border, 0 for non-border
+            'lq_path': lq_path  # center frame
+        }
+
+    def __len__(self):
+        return len(self.data_info['gt_path'])
+
+
+class VideoTestVimeo90KDataset(data.Dataset):
+    """Video test dataset for Vimeo90k-Test dataset.
+
+    It only keeps the center frame for testing.
+    For testing datasets, there is no need to prepare LMDB files.
+
+    Args:
+        opt (dict): Config for train dataset. It contains the following keys:
+            dataroot_gt (str): Data root path for gt.
+            dataroot_lq (str): Data root path for lq.
+            io_backend (dict): IO backend type and other kwarg.
+            cache_data (bool): Whether to cache testing datasets.
+            name (str): Dataset name.
+            meta_info_file (str): The path to the file storing the list of test
+                folders. If not provided, all the folders in the dataroot will
+                be used.
+            num_frame (int): Window size for input frames.
+            padding (str): Padding mode.
+    """
+
+    def __init__(self, opt):
+        super(VideoTestVimeo90KDataset, self).__init__()
+        self.opt = opt
+        self.cache_data = opt['cache_data']
+        if self.cache_data:
+            raise NotImplementedError(
+                'cache_data in Vimeo90K-Test dataset is not implemented.')
+        self.gt_root, self.lq_root = opt['dataroot_gt'], opt['dataroot_lq']
+        self.data_info = {
+            'lq_path': [],
+            'gt_path': [],
+            'folder': [],
+            'idx': [],
+            'border': []
+        }
+        neighbor_list = [
+            i + (9 - opt['num_frame']) // 2 for i in range(opt['num_frame'])
+        ]
+
+        # file client (io backend)
+        self.file_client = None
+        self.io_backend_opt = opt['io_backend']
+        assert self.io_backend_opt[
+            'type'] != 'lmdb', 'No need to use lmdb during validation/test.'
+
+        logger = get_root_logger()
+        logger.info(f'Generate data info for VideoTestDataset - {opt["name"]}')
+        with open(opt['meta_info_file'], 'r') as fin:
+            subfolders = [line.split(' ')[0] for line in fin]
+        for idx, subfolder in enumerate(subfolders):
+            gt_path = osp.join(self.gt_root, subfolder, 'im4.png')
+            self.data_info['gt_path'].append(gt_path)
+            lq_paths = [
+                osp.join(self.lq_root, subfolder, f'im{i}.png')
+                for i in neighbor_list
+            ]
+            self.data_info['lq_path'].append(lq_paths)
+            self.data_info['folder'].append('vimeo90k')
+            self.data_info['idx'].append(f'{idx}/{len(subfolders)}')
+            self.data_info['border'].append(0)
+
+    def __getitem__(self, index):
+        lq_path = self.data_info['lq_path'][index]
+        gt_path = self.data_info['gt_path'][index]
+        imgs_lq = read_img_seq(lq_path)
+        img_gt = read_img_seq([gt_path])
+        img_gt.squeeze_(0)
+
+        return {
+            'lq': imgs_lq,  # (t, c, h, w)
+            'gt': img_gt,  # (c, h, w)
+            'folder': self.data_info['folder'][index],  # folder name
+            'idx': self.data_info['idx'][index],  # e.g., 0/843
+            'border': self.data_info['border'][index],  # 0 for non-border
+            'lq_path': lq_path[self.opt['num_frame'] // 2]  # center frame
+        }
+
+    def __len__(self):
+        return len(self.data_info['gt_path'])
+
+
+class VideoTestDUFDataset(VideoTestDataset):
+    """ Video test dataset for DUF dataset.
+
+    Args:
+        opt (dict): Config for train dataset.
+            Most of keys are the same as VideoTestDataset.
+            It has the follwing extra keys:
+
+            use_duf_downsampling (bool): Whether to use duf downsampling to
+                generate low-resolution frames.
+            scale (bool): Scale, which will be added automatically.
+    """
+
+    def __getitem__(self, index):
+        folder = self.data_info['folder'][index]
+        idx, max_idx = self.data_info['idx'][index].split('/')
+        idx, max_idx = int(idx), int(max_idx)
+        border = self.data_info['border'][index]
+        lq_path = self.data_info['lq_path'][index]
+
+        select_idx = generate_frame_indices(
+            idx, max_idx, self.opt['num_frame'], padding=self.opt['padding'])
+
+        if self.cache_data:
+            if self.opt['use_duf_downsampling']:
+                # read imgs_gt to generate low-resolution frames
+                imgs_lq = self.imgs_gt[folder].index_select(
+                    0, torch.LongTensor(select_idx))
+                imgs_lq = duf_downsample(
+                    imgs_lq, kernel_size=13, scale=self.opt['scale'])
+            else:
+                imgs_lq = self.imgs_lq[folder].index_select(
+                    0, torch.LongTensor(select_idx))
+            img_gt = self.imgs_gt[folder][idx]
+        else:
+            if self.opt['use_duf_downsampling']:
+                img_paths_lq = [self.imgs_gt[folder][i] for i in select_idx]
+                # read imgs_gt to generate low-resolution frames
+                imgs_lq = read_img_seq(
+                    img_paths_lq,
+                    require_mod_crop=True,
+                    scale=self.opt['scale'])
+                imgs_lq = duf_downsample(
+                    imgs_lq, kernel_size=13, scale=self.opt['scale'])
+            else:
+                img_paths_lq = [self.imgs_lq[folder][i] for i in select_idx]
+                imgs_lq = read_img_seq(img_paths_lq)
+            img_gt = read_img_seq([self.imgs_gt[folder][idx]],
+                                  require_mod_crop=True,
+                                  scale=self.opt['scale'])
+            img_gt.squeeze_(0)
+
+        return {
+            'lq': imgs_lq,  # (t, c, h, w)
+            'gt': img_gt,  # (c, h, w)
+            'folder': folder,  # folder name
+            'idx': self.data_info['idx'][index],  # e.g., 0/99
+            'border': border,  # 1 for border, 0 for non-border
+            'lq_path': lq_path  # center frame
+        }
+
+
+class VideoRecurrentTestDataset(VideoTestDataset):
+    """Video test dataset for recurrent architectures, which takes LR video
+    frames as input and output corresponding HR video frames.
+
+    Args:
+        Same as VideoTestDataset.
+        Unused opt:
+            padding (str): Padding mode.
+
+    """
+
+    def __init__(self, opt):
+        super(VideoRecurrentTestDataset, self).__init__(opt)
+        # Find unique folder strings
+        self.folders = sorted(list(set(self.data_info['folder'])))
+
+    def __getitem__(self, index):
+        folder = self.folders[index]
+
+        if self.cache_data:
+            imgs_lq = self.imgs_lq[folder]
+            imgs_gt = self.imgs_gt[folder]
+        else:
+            raise NotImplementedError('Without cache_data is not implemented.')
+
+        return {
+            'lq': imgs_lq,
+            'gt': imgs_gt,
+            'folder': folder,
+        }
+
+    def __len__(self):
+        return len(self.folders)

NAFNet/basicsr/data/vimeo90k_dataset.py

@@ -0,0 +1,136 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+import random
+import torch
+from pathlib import Path
+from torch.utils import data as data
+
+from basicsr.data.transforms import augment, paired_random_crop
+from basicsr.utils import FileClient, get_root_logger, imfrombytes, img2tensor
+
+
+class Vimeo90KDataset(data.Dataset):
+    """Vimeo90K dataset for training.
+
+    The keys are generated from a meta info txt file.
+    basicsr/data/meta_info/meta_info_Vimeo90K_train_GT.txt
+
+    Each line contains:
+    1. clip name; 2. frame number; 3. image shape, seperated by a white space.
+    Examples:
+        00001/0001 7 (256,448,3)
+        00001/0002 7 (256,448,3)
+
+    Key examples: "00001/0001"
+    GT (gt): Ground-Truth;
+    LQ (lq): Low-Quality, e.g., low-resolution/blurry/noisy/compressed frames.
+
+    The neighboring frame list for different num_frame:
+    num_frame | frame list
+             1 | 4
+             3 | 3,4,5
+             5 | 2,3,4,5,6
+             7 | 1,2,3,4,5,6,7
+
+    Args:
+        opt (dict): Config for train dataset. It contains the following keys:
+            dataroot_gt (str): Data root path for gt.
+            dataroot_lq (str): Data root path for lq.
+            meta_info_file (str): Path for meta information file.
+            io_backend (dict): IO backend type and other kwarg.
+
+            num_frame (int): Window size for input frames.
+            gt_size (int): Cropped patched size for gt patches.
+            random_reverse (bool): Random reverse input frames.
+            use_flip (bool): Use horizontal flips.
+            use_rot (bool): Use rotation (use vertical flip and transposing h
+                and w for implementation).
+
+            scale (bool): Scale, which will be added automatically.
+    """
+
+    def __init__(self, opt):
+        super(Vimeo90KDataset, self).__init__()
+        self.opt = opt
+        self.gt_root, self.lq_root = Path(opt['dataroot_gt']), Path(
+            opt['dataroot_lq'])
+
+        with open(opt['meta_info_file'], 'r') as fin:
+            self.keys = [line.split(' ')[0] for line in fin]
+
+        # file client (io backend)
+        self.file_client = None
+        self.io_backend_opt = opt['io_backend']
+        self.is_lmdb = False
+        if self.io_backend_opt['type'] == 'lmdb':
+            self.is_lmdb = True
+            self.io_backend_opt['db_paths'] = [self.lq_root, self.gt_root]
+            self.io_backend_opt['client_keys'] = ['lq', 'gt']
+
+        # indices of input images
+        self.neighbor_list = [
+            i + (9 - opt['num_frame']) // 2 for i in range(opt['num_frame'])
+        ]
+
+        # temporal augmentation configs
+        self.random_reverse = opt['random_reverse']
+        logger = get_root_logger()
+        logger.info(f'Random reverse is {self.random_reverse}.')
+
+    def __getitem__(self, index):
+        if self.file_client is None:
+            self.file_client = FileClient(
+                self.io_backend_opt.pop('type'), **self.io_backend_opt)
+
+        # random reverse
+        if self.random_reverse and random.random() < 0.5:
+            self.neighbor_list.reverse()
+
+        scale = self.opt['scale']
+        gt_size = self.opt['gt_size']
+        key = self.keys[index]
+        clip, seq = key.split('/')  # key example: 00001/0001
+
+        # get the GT frame (im4.png)
+        if self.is_lmdb:
+            img_gt_path = f'{key}/im4'
+        else:
+            img_gt_path = self.gt_root / clip / seq / 'im4.png'
+        img_bytes = self.file_client.get(img_gt_path, 'gt')
+        img_gt = imfrombytes(img_bytes, float32=True)
+
+        # get the neighboring LQ frames
+        img_lqs = []
+        for neighbor in self.neighbor_list:
+            if self.is_lmdb:
+                img_lq_path = f'{clip}/{seq}/im{neighbor}'
+            else:
+                img_lq_path = self.lq_root / clip / seq / f'im{neighbor}.png'
+            img_bytes = self.file_client.get(img_lq_path, 'lq')
+            img_lq = imfrombytes(img_bytes, float32=True)
+            img_lqs.append(img_lq)
+
+        # randomly crop
+        img_gt, img_lqs = paired_random_crop(img_gt, img_lqs, gt_size, scale,
+                                             img_gt_path)
+
+        # augmentation - flip, rotate
+        img_lqs.append(img_gt)
+        img_results = augment(img_lqs, self.opt['use_flip'],
+                              self.opt['use_rot'])
+
+        img_results = img2tensor(img_results)
+        img_lqs = torch.stack(img_results[0:-1], dim=0)
+        img_gt = img_results[-1]
+
+        # img_lqs: (t, c, h, w)
+        # img_gt: (c, h, w)
+        # key: str
+        return {'lq': img_lqs, 'gt': img_gt, 'key': key}
+
+    def __len__(self):
+        return len(self.keys)

NAFNet/basicsr/demo.py

@@ -0,0 +1,62 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+import torch
+
+# from basicsr.data import create_dataloader, create_dataset
+from basicsr.models import create_model
+from basicsr.train import parse_options
+from basicsr.utils import FileClient, imfrombytes, img2tensor, padding, tensor2img, imwrite
+
+# from basicsr.utils import (get_env_info, get_root_logger, get_time_str,
+#                            make_exp_dirs)
+# from basicsr.utils.options import dict2str
+
+def main():
+    # parse options, set distributed setting, set ramdom seed
+    opt = parse_options(is_train=False)
+    opt['num_gpu'] = torch.cuda.device_count()
+
+    img_path = opt['img_path'].get('input_img')
+    output_path = opt['img_path'].get('output_img')
+
+
+    ## 1. read image
+    file_client = FileClient('disk')
+
+    img_bytes = file_client.get(img_path, None)
+    try:
+        img = imfrombytes(img_bytes, float32=True)
+    except:
+        raise Exception("path {} not working".format(img_path))
+
+    img = img2tensor(img, bgr2rgb=True, float32=True)
+
+
+
+    ## 2. run inference
+    opt['dist'] = False
+    model = create_model(opt)
+
+    model.feed_data(data={'lq': img.unsqueeze(dim=0)})
+
+    if model.opt['val'].get('grids', False):
+        model.grids()
+
+    model.test()
+
+    if model.opt['val'].get('grids', False):
+        model.grids_inverse()
+
+    visuals = model.get_current_visuals()
+    sr_img = tensor2img([visuals['result']])
+    imwrite(sr_img, output_path)
+
+    print(f'inference {img_path} .. finished. saved to {output_path}')
+
+if __name__ == '__main__':
+    main()
+

NAFNet/basicsr/demo_ssr.py

@@ -0,0 +1,119 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+import torch
+
+# from basicsr.data import create_dataloader, create_dataset
+from basicsr.models import create_model
+from basicsr.utils import FileClient, imfrombytes, img2tensor, padding, tensor2img, imwrite, set_random_seed
+
+import argparse
+from basicsr.utils.options import dict2str, parse
+from basicsr.utils.dist_util import get_dist_info, init_dist
+import random
+
+def parse_options(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('--local_rank', type=int, default=0)
+
+    parser.add_argument('--input_l_path', type=str, required=True, help='The path to the input left image. For stereo image inference only.')
+    parser.add_argument('--input_r_path', type=str, required=True, help='The path to the input right image. For stereo image inference only.')
+    parser.add_argument('--output_l_path', type=str, required=True, help='The path to the output left image. For stereo image inference only.')
+    parser.add_argument('--output_r_path', type=str, required=True, help='The path to the output right image. For stereo image inference only.')
+
+    args = parser.parse_args()
+    opt = parse(args.opt, is_train=is_train)
+
+    # 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)
+            print('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'])
+
+    opt['img_path'] = {
+        'input_l': args.input_l_path,
+        'input_r': args.input_r_path,
+        'output_l': args.output_l_path,
+        'output_r': args.output_r_path
+    }
+
+    return opt
+
+def imread(img_path):
+    file_client = FileClient('disk')
+    img_bytes = file_client.get(img_path, None)
+    try:
+        img = imfrombytes(img_bytes, float32=True)
+    except:
+        raise Exception("path {} not working".format(img_path))
+
+    img = img2tensor(img, bgr2rgb=True, float32=True)
+    return img
+
+def main():
+    # parse options, set distributed setting, set ramdom seed
+    opt = parse_options(is_train=False)
+    opt['num_gpu'] = torch.cuda.device_count()
+
+    img_l_path = opt['img_path'].get('input_l')
+    img_r_path = opt['img_path'].get('input_r')
+    output_l_path = opt['img_path'].get('output_l')
+    output_r_path = opt['img_path'].get('output_r')
+
+    ## 1. read image
+    img_l = imread(img_l_path)
+    img_r = imread(img_r_path)
+    img = torch.cat([img_l, img_r], dim=0)
+
+    ## 2. run inference
+    opt['dist'] = False
+    model = create_model(opt)
+
+    model.feed_data(data={'lq': img.unsqueeze(dim=0)})
+
+    if model.opt['val'].get('grids', False):
+        model.grids()
+
+    model.test()
+
+    if model.opt['val'].get('grids', False):
+        model.grids_inverse()
+
+    visuals = model.get_current_visuals()
+    sr_img_l = visuals['result'][:,:3]
+    sr_img_r = visuals['result'][:,3:]
+    sr_img_l, sr_img_r = tensor2img([sr_img_l, sr_img_r])
+    imwrite(sr_img_l, output_l_path)
+    imwrite(sr_img_r, output_r_path)
+
+    print(f'inference {img_l_path} .. finished. saved to {output_l_path}')
+    print(f'inference {img_r_path} .. finished. saved to {output_r_path}')
+
+if __name__ == '__main__':
+    main()
+

NAFNet/basicsr/metrics/__init__.py

@@ -0,0 +1,10 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+from .niqe import calculate_niqe
+from .psnr_ssim import calculate_psnr, calculate_ssim, calculate_ssim_left, calculate_psnr_left, calculate_skimage_ssim, calculate_skimage_ssim_left
+
+__all__ = ['calculate_psnr', 'calculate_ssim', 'calculate_niqe', 'calculate_ssim_left', 'calculate_psnr_left', 'calculate_skimage_ssim', 'calculate_skimage_ssim_left']

NAFNet/basicsr/metrics/fid.py

@@ -0,0 +1,108 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+import numpy as np
+import torch
+import torch.nn as nn
+from scipy import linalg
+from tqdm import tqdm
+
+from basicsr.models.archs.inception import InceptionV3
+
+
+def load_patched_inception_v3(device='cuda',
+                              resize_input=True,
+                              normalize_input=False):
+    # we may not resize the input, but in [rosinality/stylegan2-pytorch] it
+    # does resize the input.
+    inception = InceptionV3([3],
+                            resize_input=resize_input,
+                            normalize_input=normalize_input)
+    inception = nn.DataParallel(inception).eval().to(device)
+    return inception
+
+
+@torch.no_grad()
+def extract_inception_features(data_generator,
+                               inception,
+                               len_generator=None,
+                               device='cuda'):
+    """Extract inception features.
+
+    Args:
+        data_generator (generator): A data generator.
+        inception (nn.Module): Inception model.
+        len_generator (int): Length of the data_generator to show the
+            progressbar. Default: None.
+        device (str): Device. Default: cuda.
+
+    Returns:
+        Tensor: Extracted features.
+    """
+    if len_generator is not None:
+        pbar = tqdm(total=len_generator, unit='batch', desc='Extract')
+    else:
+        pbar = None
+    features = []
+
+    for data in data_generator:
+        if pbar:
+            pbar.update(1)
+        data = data.to(device)
+        feature = inception(data)[0].view(data.shape[0], -1)
+        features.append(feature.to('cpu'))
+    if pbar:
+        pbar.close()
+    features = torch.cat(features, 0)
+    return features
+
+
+def calculate_fid(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.
+
+    Args:
+        mu1 (np.array): The sample mean over activations.
+        sigma1 (np.array): The covariance matrix over activations for
+            generated samples.
+        mu2 (np.array): The sample mean over activations, precalculated on an
+               representative data set.
+        sigma2 (np.array): The covariance matrix over activations,
+            precalculated on an representative data set.
+
+    Returns:
+        float: The Frechet Distance.
+    """
+    assert mu1.shape == mu2.shape, 'Two mean vectors have different lengths'
+    assert sigma1.shape == sigma2.shape, (
+        'Two covariances have different dimensions')
+
+    cov_sqrt, _ = linalg.sqrtm(sigma1 @ sigma2, disp=False)
+
+    # Product might be almost singular
+    if not np.isfinite(cov_sqrt).all():
+        print('Product of cov matrices is singular. Adding {eps} to diagonal '
+              'of cov estimates')
+        offset = np.eye(sigma1.shape[0]) * eps
+        cov_sqrt = linalg.sqrtm((sigma1 + offset) @ (sigma2 + offset))
+
+    # Numerical error might give slight imaginary component
+    if np.iscomplexobj(cov_sqrt):
+        if not np.allclose(np.diagonal(cov_sqrt).imag, 0, atol=1e-3):
+            m = np.max(np.abs(cov_sqrt.imag))
+            raise ValueError(f'Imaginary component {m}')
+        cov_sqrt = cov_sqrt.real
+
+    mean_diff = mu1 - mu2
+    mean_norm = mean_diff @ mean_diff
+    trace = np.trace(sigma1) + np.trace(sigma2) - 2 * np.trace(cov_sqrt)
+    fid = mean_norm + trace
+
+    return fid

NAFNet/basicsr/metrics/metric_util.py

@@ -0,0 +1,53 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+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.

NAFNet/basicsr/metrics/niqe.py

@@ -0,0 +1,211 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+import cv2
+import math
+import numpy as np
+from scipy.ndimage.filters import convolve
+from scipy.special import gamma
+
+from basicsr.metrics.metric_util import reorder_image, to_y_channel
+
+
+def estimate_aggd_param(block):
+    """Estimate AGGD (Asymmetric Generalized Gaussian Distribution) paramters.
+
+    Args:
+        block (ndarray): 2D Image block.
+
+    Returns:
+        tuple: alpha (float), beta_l (float) and beta_r (float) for the AGGD
+            distribution (Estimating the parames in Equation 7 in the paper).
+    """
+    block = block.flatten()
+    gam = np.arange(0.2, 10.001, 0.001)  # len = 9801
+    gam_reciprocal = np.reciprocal(gam)
+    r_gam = np.square(gamma(gam_reciprocal * 2)) / (
+        gamma(gam_reciprocal) * gamma(gam_reciprocal * 3))
+
+    left_std = np.sqrt(np.mean(block[block < 0]**2))
+    right_std = np.sqrt(np.mean(block[block > 0]**2))
+    gammahat = left_std / right_std
+    rhat = (np.mean(np.abs(block)))**2 / np.mean(block**2)
+    rhatnorm = (rhat * (gammahat**3 + 1) *
+                (gammahat + 1)) / ((gammahat**2 + 1)**2)
+    array_position = np.argmin((r_gam - rhatnorm)**2)
+
+    alpha = gam[array_position]
+    beta_l = left_std * np.sqrt(gamma(1 / alpha) / gamma(3 / alpha))
+    beta_r = right_std * np.sqrt(gamma(1 / alpha) / gamma(3 / alpha))
+    return (alpha, beta_l, beta_r)
+
+
+def compute_feature(block):
+    """Compute features.
+
+    Args:
+        block (ndarray): 2D Image block.
+
+    Returns:
+        list: Features with length of 18.
+    """
+    feat = []
+    alpha, beta_l, beta_r = estimate_aggd_param(block)
+    feat.extend([alpha, (beta_l + beta_r) / 2])
+
+    # distortions disturb the fairly regular structure of natural images.
+    # This deviation can be captured by analyzing the sample distribution of
+    # the products of pairs of adjacent coefficients computed along
+    # horizontal, vertical and diagonal orientations.
+    shifts = [[0, 1], [1, 0], [1, 1], [1, -1]]
+    for i in range(len(shifts)):
+        shifted_block = np.roll(block, shifts[i], axis=(0, 1))
+        alpha, beta_l, beta_r = estimate_aggd_param(block * shifted_block)
+        # Eq. 8
+        mean = (beta_r - beta_l) * (gamma(2 / alpha) / gamma(1 / alpha))
+        feat.extend([alpha, mean, beta_l, beta_r])
+    return feat
+
+
+def niqe(img,
+         mu_pris_param,
+         cov_pris_param,
+         gaussian_window,
+         block_size_h=96,
+         block_size_w=96):
+    """Calculate NIQE (Natural Image Quality Evaluator) metric.
+
+    Ref: Making a "Completely Blind" Image Quality Analyzer.
+    This implementation could produce almost the same results as the official
+    MATLAB codes: http://live.ece.utexas.edu/research/quality/niqe_release.zip
+
+    Note that we do not include block overlap height and width, since they are
+    always 0 in the official implementation.
+
+    For good performance, it is advisable by the official implemtation to
+    divide the distorted image in to the same size patched as used for the
+    construction of multivariate Gaussian model.
+
+    Args:
+        img (ndarray): Input image whose quality needs to be computed. The
+            image must be a gray or Y (of YCbCr) image with shape (h, w).
+            Range [0, 255] with float type.
+        mu_pris_param (ndarray): Mean of a pre-defined multivariate Gaussian
+            model calculated on the pristine dataset.
+        cov_pris_param (ndarray): Covariance of a pre-defined multivariate
+            Gaussian model calculated on the pristine dataset.
+        gaussian_window (ndarray): A 7x7 Gaussian window used for smoothing the
+            image.
+        block_size_h (int): Height of the blocks in to which image is divided.
+            Default: 96 (the official recommended value).
+        block_size_w (int): Width of the blocks in to which image is divided.
+            Default: 96 (the official recommended value).
+    """
+    assert img.ndim == 2, (
+        'Input image must be a gray or Y (of YCbCr) image with shape (h, w).')
+    # crop image
+    h, w = img.shape
+    num_block_h = math.floor(h / block_size_h)
+    num_block_w = math.floor(w / block_size_w)
+    img = img[0:num_block_h * block_size_h, 0:num_block_w * block_size_w]
+
+    distparam = []  # dist param is actually the multiscale features
+    for scale in (1, 2):  # perform on two scales (1, 2)
+        mu = convolve(img, gaussian_window, mode='nearest')
+        sigma = np.sqrt(
+            np.abs(
+                convolve(np.square(img), gaussian_window, mode='nearest') -
+                np.square(mu)))
+        # normalize, as in Eq. 1 in the paper
+        img_nomalized = (img - mu) / (sigma + 1)
+
+        feat = []
+        for idx_w in range(num_block_w):
+            for idx_h in range(num_block_h):
+                # process ecah block
+                block = img_nomalized[idx_h * block_size_h //
+                                      scale:(idx_h + 1) * block_size_h //
+                                      scale, idx_w * block_size_w //
+                                      scale:(idx_w + 1) * block_size_w //
+                                      scale]
+                feat.append(compute_feature(block))
+
+        distparam.append(np.array(feat))
+        # TODO: matlab bicubic downsample with anti-aliasing
+        # for simplicity, now we use opencv instead, which will result in
+        # a slight difference.
+        if scale == 1:
+            h, w = img.shape
+            img = cv2.resize(
+                img / 255., (w // 2, h // 2), interpolation=cv2.INTER_LINEAR)
+            img = img * 255.
+
+    distparam = np.concatenate(distparam, axis=1)
+
+    # fit a MVG (multivariate Gaussian) model to distorted patch features
+    mu_distparam = np.nanmean(distparam, axis=0)
+    # use nancov. ref: https://ww2.mathworks.cn/help/stats/nancov.html
+    distparam_no_nan = distparam[~np.isnan(distparam).any(axis=1)]
+    cov_distparam = np.cov(distparam_no_nan, rowvar=False)
+
+    # compute niqe quality, Eq. 10 in the paper
+    invcov_param = np.linalg.pinv((cov_pris_param + cov_distparam) / 2)
+    quality = np.matmul(
+        np.matmul((mu_pris_param - mu_distparam), invcov_param),
+        np.transpose((mu_pris_param - mu_distparam)))
+    quality = np.sqrt(quality)
+
+    return quality
+
+
+def calculate_niqe(img, crop_border, input_order='HWC', convert_to='y'):
+    """Calculate NIQE (Natural Image Quality Evaluator) metric.
+
+    Ref: Making a "Completely Blind" Image Quality Analyzer.
+    This implementation could produce almost the same results as the official
+    MATLAB codes: http://live.ece.utexas.edu/research/quality/niqe_release.zip
+
+    We use the official params estimated from the pristine dataset.
+    We use the recommended block size (96, 96) without overlaps.
+
+    Args:
+        img (ndarray): Input image whose quality needs to be computed.
+            The input image must be in range [0, 255] with float/int type.
+            The input_order of image can be 'HW' or 'HWC' or 'CHW'. (BGR order)
+            If the input order is 'HWC' or 'CHW', it will be converted to gray
+            or Y (of YCbCr) image according to the ``convert_to`` argument.
+        crop_border (int): Cropped pixels in each edge of an image. These
+            pixels are not involved in the metric calculation.
+        input_order (str): Whether the input order is 'HW', 'HWC' or 'CHW'.
+            Default: 'HWC'.
+        convert_to (str): Whether coverted to 'y' (of MATLAB YCbCr) or 'gray'.
+            Default: 'y'.
+
+    Returns:
+        float: NIQE result.
+    """
+
+    # we use the official params estimated from the pristine dataset.
+    niqe_pris_params = np.load('basicsr/metrics/niqe_pris_params.npz')
+    mu_pris_param = niqe_pris_params['mu_pris_param']
+    cov_pris_param = niqe_pris_params['cov_pris_param']
+    gaussian_window = niqe_pris_params['gaussian_window']
+
+    img = img.astype(np.float32)
+    if input_order != 'HW':
+        img = reorder_image(img, input_order=input_order)
+        if convert_to == 'y':
+            img = to_y_channel(img)
+        elif convert_to == 'gray':
+            img = cv2.cvtColor(img / 255., cv2.COLOR_BGR2GRAY) * 255.
+        img = np.squeeze(img)
+
+    if crop_border != 0:
+        img = img[crop_border:-crop_border, crop_border:-crop_border]
+
+    niqe_result = niqe(img, mu_pris_param, cov_pris_param, gaussian_window)
+
+    return niqe_result

NAFNet/basicsr/metrics/niqe_pris_params.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2a7c182a68c9e7f1b2e2e5ec723279d6f65d912b6fcaf37eb2bf03d7367c4296
+size 11850

NAFNet/basicsr/metrics/psnr_ssim.py

@@ -0,0 +1,358 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# modified from https://github.com/mayorx/matlab_ssim_pytorch_implementation/blob/main/calc_ssim.py
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+import cv2
+import numpy as np
+
+from basicsr.metrics.metric_util import reorder_image, to_y_channel
+from skimage.metrics import structural_similarity
+import torch
+
+def calculate_psnr(img1,
+                   img2,
+                   crop_border,
+                   input_order='HWC',
+                   test_y_channel=False):
+    """Calculate PSNR (Peak Signal-to-Noise Ratio).
+
+    Ref: https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio
+
+    Args:
+        img1 (ndarray/tensor): Images with range [0, 255]/[0, 1].
+        img2 (ndarray/tensor): Images with range [0, 255]/[0, 1].
+        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 img1.shape == img2.shape, (
+        f'Image shapes are differnet: {img1.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"')
+    if type(img1) == torch.Tensor:
+        if len(img1.shape) == 4:
+            img1 = img1.squeeze(0)
+        img1 = img1.detach().cpu().numpy().transpose(1,2,0)
+    if type(img2) == torch.Tensor:
+        if len(img2.shape) == 4:
+            img2 = img2.squeeze(0)
+        img2 = img2.detach().cpu().numpy().transpose(1,2,0)
+        
+    img1 = reorder_image(img1, input_order=input_order)
+    img2 = reorder_image(img2, input_order=input_order)
+    img1 = img1.astype(np.float64)
+    img2 = img2.astype(np.float64)
+
+    if crop_border != 0:
+        img1 = img1[crop_border:-crop_border, crop_border:-crop_border, ...]
+        img2 = img2[crop_border:-crop_border, crop_border:-crop_border, ...]
+    
+    def _psnr(img1, img2):
+        if test_y_channel:
+            img1 = to_y_channel(img1)
+            img2 = to_y_channel(img2)
+
+        mse = np.mean((img1 - img2)**2)
+        if mse == 0:
+            return float('inf')
+        max_value = 1. if img1.max() <= 1 else 255.
+        return 20. * np.log10(max_value / np.sqrt(mse))
+    
+    if img1.ndim == 3 and img1.shape[2] == 6:
+        l1, r1 = img1[:,:,:3], img1[:,:,3:]
+        l2, r2 = img2[:,:,:3], img2[:,:,3:]
+        return (_psnr(l1, l2) + _psnr(r1, r2))/2
+    else:
+        return _psnr(img1, img2)
+
+def calculate_psnr_left(img1,
+                   img2,
+                   crop_border,
+                   input_order='HWC',
+                   test_y_channel=False):
+    assert input_order == 'HWC'
+    assert crop_border == 0
+
+    img1 = img1[:,64:,:3]
+    img2 = img2[:,64:,:3]
+    return calculate_psnr(img1=img1, img2=img2, crop_border=0, input_order=input_order, test_y_channel=test_y_channel)
+
+def _ssim(img1, img2, max_value):
+    """Calculate SSIM (structural similarity) for one channel images.
+
+    It is called by func:`calculate_ssim`.
+
+    Args:
+        img1 (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 * max_value)**2
+    C2 = (0.03 * max_value)**2
+
+    img1 = img1.astype(np.float64)
+    img2 = img2.astype(np.float64)
+    kernel = cv2.getGaussianKernel(11, 1.5)
+    window = np.outer(kernel, kernel.transpose())
+
+    mu1 = cv2.filter2D(img1, -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(img1**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(img1 * 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()
+
+def prepare_for_ssim(img, k):
+    import torch
+    with torch.no_grad():
+        img = torch.from_numpy(img).unsqueeze(0).unsqueeze(0).float()
+        conv = torch.nn.Conv2d(1, 1, k, stride=1, padding=k//2, padding_mode='reflect')
+        conv.weight.requires_grad = False
+        conv.weight[:, :, :, :] = 1. / (k * k)
+
+        img = conv(img)
+
+        img = img.squeeze(0).squeeze(0)
+        img = img[0::k, 0::k]
+    return img.detach().cpu().numpy()
+
+def prepare_for_ssim_rgb(img, k):
+    import torch
+    with torch.no_grad():
+        img = torch.from_numpy(img).float() #HxWx3
+
+        conv = torch.nn.Conv2d(1, 1, k, stride=1, padding=k // 2, padding_mode='reflect')
+        conv.weight.requires_grad = False
+        conv.weight[:, :, :, :] = 1. / (k * k)
+
+        new_img = []
+
+        for i in range(3):
+            new_img.append(conv(img[:, :, i].unsqueeze(0).unsqueeze(0)).squeeze(0).squeeze(0)[0::k, 0::k])
+
+    return torch.stack(new_img, dim=2).detach().cpu().numpy()
+
+def _3d_gaussian_calculator(img, conv3d):
+    out = conv3d(img.unsqueeze(0).unsqueeze(0)).squeeze(0).squeeze(0)
+    return out
+
+def _generate_3d_gaussian_kernel():
+    kernel = cv2.getGaussianKernel(11, 1.5)
+    window = np.outer(kernel, kernel.transpose())
+    kernel_3 = cv2.getGaussianKernel(11, 1.5)
+    kernel = torch.tensor(np.stack([window * k for k in kernel_3], axis=0))
+    conv3d = torch.nn.Conv3d(1, 1, (11, 11, 11), stride=1, padding=(5, 5, 5), bias=False, padding_mode='replicate')
+    conv3d.weight.requires_grad = False
+    conv3d.weight[0, 0, :, :, :] = kernel
+    return conv3d
+
+def _ssim_3d(img1, img2, max_value):
+    assert len(img1.shape) == 3 and len(img2.shape) == 3
+    """Calculate SSIM (structural similarity) for one channel images.
+
+    It is called by func:`calculate_ssim`.
+
+    Args:
+        img1 (ndarray): Images with range [0, 255]/[0, 1] with order 'HWC'.
+        img2 (ndarray): Images with range [0, 255]/[0, 1] with order 'HWC'.
+
+    Returns:
+        float: ssim result.
+    """
+    C1 = (0.01 * max_value) ** 2
+    C2 = (0.03 * max_value) ** 2
+    img1 = img1.astype(np.float64)
+    img2 = img2.astype(np.float64)
+
+    kernel = _generate_3d_gaussian_kernel().cuda()
+
+    img1 = torch.tensor(img1).float().cuda()
+    img2 = torch.tensor(img2).float().cuda()
+
+
+    mu1 = _3d_gaussian_calculator(img1, kernel)
+    mu2 = _3d_gaussian_calculator(img2, kernel)
+
+    mu1_sq = mu1 ** 2
+    mu2_sq = mu2 ** 2
+    mu1_mu2 = mu1 * mu2
+    sigma1_sq = _3d_gaussian_calculator(img1 ** 2, kernel) - mu1_sq
+    sigma2_sq = _3d_gaussian_calculator(img2 ** 2, kernel) - mu2_sq
+    sigma12 = _3d_gaussian_calculator(img1*img2, kernel) - mu1_mu2
+
+    ssim_map = ((2 * mu1_mu2 + C1) *
+                (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) *
+                                       (sigma1_sq + sigma2_sq + C2))
+    return float(ssim_map.mean())
+
+def _ssim_cly(img1, img2):
+    assert len(img1.shape) == 2 and len(img2.shape) == 2
+    """Calculate SSIM (structural similarity) for one channel images.
+
+    It is called by func:`calculate_ssim`.
+
+    Args:
+        img1 (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
+    img1 = img1.astype(np.float64)
+    img2 = img2.astype(np.float64)
+
+    kernel = cv2.getGaussianKernel(11, 1.5)
+    # print(kernel)
+    window = np.outer(kernel, kernel.transpose())
+
+    bt = cv2.BORDER_REPLICATE
+
+    mu1 = cv2.filter2D(img1, -1, window, borderType=bt)
+    mu2 = cv2.filter2D(img2, -1, window,borderType=bt)
+
+    mu1_sq = mu1**2
+    mu2_sq = mu2**2
+    mu1_mu2 = mu1 * mu2
+    sigma1_sq = cv2.filter2D(img1**2, -1, window, borderType=bt) - mu1_sq
+    sigma2_sq = cv2.filter2D(img2**2, -1, window, borderType=bt) - mu2_sq
+    sigma12 = cv2.filter2D(img1 * img2, -1, window, borderType=bt) - 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()
+
+
+def calculate_ssim(img1,
+                   img2,
+                   crop_border,
+                   input_order='HWC',
+                   test_y_channel=False,
+                   ssim3d=True):
+    """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:
+        img1 (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 img1.shape == img2.shape, (
+        f'Image shapes are differnet: {img1.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"')
+
+    if type(img1) == torch.Tensor:
+        if len(img1.shape) == 4:
+            img1 = img1.squeeze(0)
+        img1 = img1.detach().cpu().numpy().transpose(1,2,0)
+    if type(img2) == torch.Tensor:
+        if len(img2.shape) == 4:
+            img2 = img2.squeeze(0)
+        img2 = img2.detach().cpu().numpy().transpose(1,2,0)
+
+    img1 = reorder_image(img1, input_order=input_order)
+    img2 = reorder_image(img2, input_order=input_order)
+
+    img1 = img1.astype(np.float64)
+    img2 = img2.astype(np.float64)
+
+    if crop_border != 0:
+        img1 = img1[crop_border:-crop_border, crop_border:-crop_border, ...]
+        img2 = img2[crop_border:-crop_border, crop_border:-crop_border, ...]
+
+    def _cal_ssim(img1, img2):
+        if test_y_channel:
+            img1 = to_y_channel(img1)
+            img2 = to_y_channel(img2)
+            return _ssim_cly(img1[..., 0], img2[..., 0])
+
+        ssims = []
+        # ssims_before = []
+
+        # skimage_before = skimage.metrics.structural_similarity(img1, img2, data_range=255., multichannel=True)
+        # print('.._skimage',
+        #       skimage.metrics.structural_similarity(img1, img2, data_range=255., multichannel=True))
+        max_value = 1 if img1.max() <= 1 else 255
+        with torch.no_grad():
+            final_ssim = _ssim_3d(img1, img2, max_value) if ssim3d else _ssim(img1, img2, max_value)
+            ssims.append(final_ssim)
+
+        # for i in range(img1.shape[2]):
+        #     ssims_before.append(_ssim(img1, img2))
+
+        # print('..ssim mean , new {:.4f}  and before {:.4f} .... skimage before {:.4f}'.format(np.array(ssims).mean(), np.array(ssims_before).mean(), skimage_before))
+            # ssims.append(skimage.metrics.structural_similarity(img1[..., i], img2[..., i], multichannel=False))
+
+        return np.array(ssims).mean()
+
+    if img1.ndim == 3 and img1.shape[2] == 6:
+        l1, r1 = img1[:,:,:3], img1[:,:,3:]
+        l2, r2 = img2[:,:,:3], img2[:,:,3:]
+        return (_cal_ssim(l1, l2) + _cal_ssim(r1, r2))/2
+    else:
+        return _cal_ssim(img1, img2)
+
+def calculate_ssim_left(img1,
+                   img2,
+                   crop_border,
+                   input_order='HWC',
+                   test_y_channel=False,
+                   ssim3d=True):
+    assert input_order == 'HWC'
+    assert crop_border == 0
+
+    img1 = img1[:,64:,:3]
+    img2 = img2[:,64:,:3]
+    return calculate_ssim(img1=img1, img2=img2, crop_border=0, input_order=input_order, test_y_channel=test_y_channel, ssim3d=ssim3d)
+
+def calculate_skimage_ssim(img1, img2):
+    return structural_similarity(img1, img2, multichannel=True)
+
+def calculate_skimage_ssim_left(img1, img2):
+    img1 = img1[:,64:,:3]
+    img2 = img2[:,64:,:3]
+    return calculate_skimage_ssim(img1=img1, img2=img2)

NAFNet/basicsr/models/__init__.py

@@ -0,0 +1,48 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+import importlib
+from os import path as osp
+
+from basicsr.utils import get_root_logger, scandir
+
+# automatically scan and import model modules
+# 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 create_model(opt):
+    """Create model.
+
+    Args:
+        opt (dict): Configuration. It constains:
+            model_type (str): Model type.
+    """
+    model_type = opt['model_type']
+
+    # dynamic instantiation
+    for module in _model_modules:
+        model_cls = getattr(module, model_type, None)
+        if model_cls is not None:
+            break
+    if model_cls is None:
+        raise ValueError(f'Model {model_type} is not found.')
+
+    model = model_cls(opt)
+
+    logger = get_root_logger()
+    logger.info(f'Model [{model.__class__.__name__}] is created.')
+    return model

NAFNet/basicsr/models/archs/Baseline_arch.py

@@ -0,0 +1,202 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+
+'''
+Simple Baselines for Image Restoration
+
+@article{chen2022simple,
+  title={Simple Baselines for Image Restoration},
+  author={Chen, Liangyu and Chu, Xiaojie and Zhang, Xiangyu and Sun, Jian},
+  journal={arXiv preprint arXiv:2204.04676},
+  year={2022}
+}
+'''
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from basicsr.models.archs.arch_util import LayerNorm2d
+from basicsr.models.archs.local_arch import Local_Base
+
+class BaselineBlock(nn.Module):
+    def __init__(self, c, DW_Expand=1, FFN_Expand=2, drop_out_rate=0.):
+        super().__init__()
+        dw_channel = c * DW_Expand
+        self.conv1 = nn.Conv2d(in_channels=c, out_channels=dw_channel, kernel_size=1, padding=0, stride=1, groups=1, bias=True)
+        self.conv2 = nn.Conv2d(in_channels=dw_channel, out_channels=dw_channel, kernel_size=3, padding=1, stride=1, groups=dw_channel,
+                               bias=True)
+        self.conv3 = nn.Conv2d(in_channels=dw_channel, out_channels=c, kernel_size=1, padding=0, stride=1, groups=1, bias=True)
+        
+        # Channel Attention
+        self.se = nn.Sequential(
+            nn.AdaptiveAvgPool2d(1),
+            nn.Conv2d(in_channels=dw_channel, out_channels=dw_channel // 2, kernel_size=1, padding=0, stride=1,
+                      groups=1, bias=True),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels=dw_channel // 2, out_channels=dw_channel, kernel_size=1, padding=0, stride=1,
+                      groups=1, bias=True),
+            nn.Sigmoid()
+        )
+
+        # GELU
+        self.gelu = nn.GELU()
+
+        ffn_channel = FFN_Expand * c
+        self.conv4 = nn.Conv2d(in_channels=c, out_channels=ffn_channel, kernel_size=1, padding=0, stride=1, groups=1, bias=True)
+        self.conv5 = nn.Conv2d(in_channels=ffn_channel, out_channels=c, kernel_size=1, padding=0, stride=1, groups=1, bias=True)
+
+        self.norm1 = LayerNorm2d(c)
+        self.norm2 = LayerNorm2d(c)
+
+        self.dropout1 = nn.Dropout(drop_out_rate) if drop_out_rate > 0. else nn.Identity()
+        self.dropout2 = nn.Dropout(drop_out_rate) if drop_out_rate > 0. else nn.Identity()
+
+        self.beta = nn.Parameter(torch.zeros((1, c, 1, 1)), requires_grad=True)
+        self.gamma = nn.Parameter(torch.zeros((1, c, 1, 1)), requires_grad=True)
+
+    def forward(self, inp):
+        x = inp
+
+        x = self.norm1(x)
+
+        x = self.conv1(x)
+        x = self.conv2(x)
+        x = self.gelu(x)
+        x = x * self.se(x)
+        x = self.conv3(x)
+
+        x = self.dropout1(x)
+
+        y = inp + x * self.beta
+
+        x = self.conv4(self.norm2(y))
+        x = self.gelu(x)
+        x = self.conv5(x)
+
+        x = self.dropout2(x)
+
+        return y + x * self.gamma
+
+
+class Baseline(nn.Module):
+
+    def __init__(self, img_channel=3, width=16, middle_blk_num=1, enc_blk_nums=[], dec_blk_nums=[], dw_expand=1, ffn_expand=2):
+        super().__init__()
+
+        self.intro = nn.Conv2d(in_channels=img_channel, out_channels=width, kernel_size=3, padding=1, stride=1, groups=1,
+                              bias=True)
+        self.ending = nn.Conv2d(in_channels=width, out_channels=img_channel, kernel_size=3, padding=1, stride=1, groups=1,
+                              bias=True)
+
+        self.encoders = nn.ModuleList()
+        self.decoders = nn.ModuleList()
+        self.middle_blks = nn.ModuleList()
+        self.ups = nn.ModuleList()
+        self.downs = nn.ModuleList()
+
+        chan = width
+        for num in enc_blk_nums:
+            self.encoders.append(
+                nn.Sequential(
+                    *[BaselineBlock(chan, dw_expand, ffn_expand) for _ in range(num)]
+                )
+            )
+            self.downs.append(
+                nn.Conv2d(chan, 2*chan, 2, 2)
+            )
+            chan = chan * 2
+
+        self.middle_blks = \
+            nn.Sequential(
+                *[BaselineBlock(chan, dw_expand, ffn_expand) for _ in range(middle_blk_num)]
+            )
+
+        for num in dec_blk_nums:
+            self.ups.append(
+                nn.Sequential(
+                    nn.Conv2d(chan, chan * 2, 1, bias=False),
+                    nn.PixelShuffle(2)
+                )
+            )
+            chan = chan // 2
+            self.decoders.append(
+                nn.Sequential(
+                    *[BaselineBlock(chan, dw_expand, ffn_expand) for _ in range(num)]
+                )
+            )
+
+        self.padder_size = 2 ** len(self.encoders)
+
+    def forward(self, inp):
+        B, C, H, W = inp.shape
+        inp = self.check_image_size(inp)
+
+        x = self.intro(inp)
+
+        encs = []
+
+        for encoder, down in zip(self.encoders, self.downs):
+            x = encoder(x)
+            encs.append(x)
+            x = down(x)
+
+        x = self.middle_blks(x)
+
+        for decoder, up, enc_skip in zip(self.decoders, self.ups, encs[::-1]):
+            x = up(x)
+            x = x + enc_skip
+            x = decoder(x)
+
+        x = self.ending(x)
+        x = x + inp
+
+        return x[:, :, :H, :W]
+
+    def check_image_size(self, x):
+        _, _, h, w = x.size()
+        mod_pad_h = (self.padder_size - h % self.padder_size) % self.padder_size
+        mod_pad_w = (self.padder_size - w % self.padder_size) % self.padder_size
+        x = F.pad(x, (0, mod_pad_w, 0, mod_pad_h))
+        return x
+
+class BaselineLocal(Local_Base, Baseline):
+    def __init__(self, *args, train_size=(1, 3, 256, 256), fast_imp=False, **kwargs):
+        Local_Base.__init__(self)
+        Baseline.__init__(self, *args, **kwargs)
+
+        N, C, H, W = train_size
+        base_size = (int(H * 1.5), int(W * 1.5))
+
+        self.eval()
+        with torch.no_grad():
+            self.convert(base_size=base_size, train_size=train_size, fast_imp=fast_imp)
+
+if __name__ == '__main__':
+    img_channel = 3
+    width = 32
+
+    dw_expand = 1
+    ffn_expand = 2
+
+    # enc_blks = [2, 2, 4, 8]
+    # middle_blk_num = 12
+    # dec_blks = [2, 2, 2, 2]
+
+    enc_blks = [1, 1, 1, 28]
+    middle_blk_num = 1
+    dec_blks = [1, 1, 1, 1]
+
+    net = Baseline(img_channel=img_channel, width=width, middle_blk_num=middle_blk_num,
+                 enc_blk_nums=enc_blks, dec_blk_nums=dec_blks, dw_expand=dw_expand, ffn_expand=ffn_expand)
+
+    inp_shape = (3, 256, 256)
+
+    from ptflops import get_model_complexity_info
+
+    macs, params = get_model_complexity_info(net, inp_shape, verbose=False, print_per_layer_stat=False)
+
+    params = float(params[:-3])
+    macs = float(macs[:-4])
+
+    print(macs, params)

NAFNet/basicsr/models/archs/NAFNet_arch.py

@@ -0,0 +1,202 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+
+'''
+Simple Baselines for Image Restoration
+
+@article{chen2022simple,
+  title={Simple Baselines for Image Restoration},
+  author={Chen, Liangyu and Chu, Xiaojie and Zhang, Xiangyu and Sun, Jian},
+  journal={arXiv preprint arXiv:2204.04676},
+  year={2022}
+}
+'''
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from basicsr.models.archs.arch_util import LayerNorm2d
+from basicsr.models.archs.local_arch import Local_Base
+
+class SimpleGate(nn.Module):
+    def forward(self, x):
+        x1, x2 = x.chunk(2, dim=1)
+        return x1 * x2
+
+class NAFBlock(nn.Module):
+    def __init__(self, c, DW_Expand=2, FFN_Expand=2, drop_out_rate=0.):
+        super().__init__()
+        dw_channel = c * DW_Expand
+        self.conv1 = nn.Conv2d(in_channels=c, out_channels=dw_channel, kernel_size=1, padding=0, stride=1, groups=1, bias=True)
+        self.conv2 = nn.Conv2d(in_channels=dw_channel, out_channels=dw_channel, kernel_size=3, padding=1, stride=1, groups=dw_channel,
+                               bias=True)
+        self.conv3 = nn.Conv2d(in_channels=dw_channel // 2, out_channels=c, kernel_size=1, padding=0, stride=1, groups=1, bias=True)
+        
+        # Simplified Channel Attention
+        self.sca = nn.Sequential(
+            nn.AdaptiveAvgPool2d(1),
+            nn.Conv2d(in_channels=dw_channel // 2, out_channels=dw_channel // 2, kernel_size=1, padding=0, stride=1,
+                      groups=1, bias=True),
+        )
+
+        # SimpleGate
+        self.sg = SimpleGate()
+
+        ffn_channel = FFN_Expand * c
+        self.conv4 = nn.Conv2d(in_channels=c, out_channels=ffn_channel, kernel_size=1, padding=0, stride=1, groups=1, bias=True)
+        self.conv5 = nn.Conv2d(in_channels=ffn_channel // 2, out_channels=c, kernel_size=1, padding=0, stride=1, groups=1, bias=True)
+
+        self.norm1 = LayerNorm2d(c)
+        self.norm2 = LayerNorm2d(c)
+
+        self.dropout1 = nn.Dropout(drop_out_rate) if drop_out_rate > 0. else nn.Identity()
+        self.dropout2 = nn.Dropout(drop_out_rate) if drop_out_rate > 0. else nn.Identity()
+
+        self.beta = nn.Parameter(torch.zeros((1, c, 1, 1)), requires_grad=True)
+        self.gamma = nn.Parameter(torch.zeros((1, c, 1, 1)), requires_grad=True)
+
+    def forward(self, inp):
+        x = inp
+
+        x = self.norm1(x)
+
+        x = self.conv1(x)
+        x = self.conv2(x)
+        x = self.sg(x)
+        x = x * self.sca(x)
+        x = self.conv3(x)
+
+        x = self.dropout1(x)
+
+        y = inp + x * self.beta
+
+        x = self.conv4(self.norm2(y))
+        x = self.sg(x)
+        x = self.conv5(x)
+
+        x = self.dropout2(x)
+
+        return y + x * self.gamma
+
+
+class NAFNet(nn.Module):
+
+    def __init__(self, img_channel=3, width=16, middle_blk_num=1, enc_blk_nums=[], dec_blk_nums=[]):
+        super().__init__()
+
+        self.intro = nn.Conv2d(in_channels=img_channel, out_channels=width, kernel_size=3, padding=1, stride=1, groups=1,
+                              bias=True)
+        self.ending = nn.Conv2d(in_channels=width, out_channels=img_channel, kernel_size=3, padding=1, stride=1, groups=1,
+                              bias=True)
+
+        self.encoders = nn.ModuleList()
+        self.decoders = nn.ModuleList()
+        self.middle_blks = nn.ModuleList()
+        self.ups = nn.ModuleList()
+        self.downs = nn.ModuleList()
+
+        chan = width
+        for num in enc_blk_nums:
+            self.encoders.append(
+                nn.Sequential(
+                    *[NAFBlock(chan) for _ in range(num)]
+                )
+            )
+            self.downs.append(
+                nn.Conv2d(chan, 2*chan, 2, 2)
+            )
+            chan = chan * 2
+
+        self.middle_blks = \
+            nn.Sequential(
+                *[NAFBlock(chan) for _ in range(middle_blk_num)]
+            )
+
+        for num in dec_blk_nums:
+            self.ups.append(
+                nn.Sequential(
+                    nn.Conv2d(chan, chan * 2, 1, bias=False),
+                    nn.PixelShuffle(2)
+                )
+            )
+            chan = chan // 2
+            self.decoders.append(
+                nn.Sequential(
+                    *[NAFBlock(chan) for _ in range(num)]
+                )
+            )
+
+        self.padder_size = 2 ** len(self.encoders)
+
+    def forward(self, inp):
+        B, C, H, W = inp.shape
+        inp = self.check_image_size(inp)
+
+        x = self.intro(inp)
+
+        encs = []
+
+        for encoder, down in zip(self.encoders, self.downs):
+            x = encoder(x)
+            encs.append(x)
+            x = down(x)
+
+        x = self.middle_blks(x)
+
+        for decoder, up, enc_skip in zip(self.decoders, self.ups, encs[::-1]):
+            x = up(x)
+            x = x + enc_skip
+            x = decoder(x)
+
+        x = self.ending(x)
+        x = x + inp
+
+        return x[:, :, :H, :W]
+
+    def check_image_size(self, x):
+        _, _, h, w = x.size()
+        mod_pad_h = (self.padder_size - h % self.padder_size) % self.padder_size
+        mod_pad_w = (self.padder_size - w % self.padder_size) % self.padder_size
+        x = F.pad(x, (0, mod_pad_w, 0, mod_pad_h))
+        return x
+
+class NAFNetLocal(Local_Base, NAFNet):
+    def __init__(self, *args, train_size=(1, 3, 256, 256), fast_imp=False, **kwargs):
+        Local_Base.__init__(self)
+        NAFNet.__init__(self, *args, **kwargs)
+
+        N, C, H, W = train_size
+        base_size = (int(H * 1.5), int(W * 1.5))
+
+        self.eval()
+        with torch.no_grad():
+            self.convert(base_size=base_size, train_size=train_size, fast_imp=fast_imp)
+
+
+if __name__ == '__main__':
+    img_channel = 3
+    width = 32
+
+    # enc_blks = [2, 2, 4, 8]
+    # middle_blk_num = 12
+    # dec_blks = [2, 2, 2, 2]
+
+    enc_blks = [1, 1, 1, 28]
+    middle_blk_num = 1
+    dec_blks = [1, 1, 1, 1]
+    
+    net = NAFNet(img_channel=img_channel, width=width, middle_blk_num=middle_blk_num,
+                      enc_blk_nums=enc_blks, dec_blk_nums=dec_blks)
+
+
+    inp_shape = (3, 256, 256)
+
+    from ptflops import get_model_complexity_info
+
+    macs, params = get_model_complexity_info(net, inp_shape, verbose=False, print_per_layer_stat=False)
+
+    params = float(params[:-3])
+    macs = float(macs[:-4])
+
+    print(macs, params)

NAFNet/basicsr/models/archs/NAFSSR_arch.py

@@ -0,0 +1,170 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+
+'''
+NAFSSR: Stereo Image Super-Resolution Using NAFNet
+
+@InProceedings{Chu2022NAFSSR,
+  author    = {Xiaojie Chu and Liangyu Chen and Wenqing Yu},
+  title     = {NAFSSR: Stereo Image Super-Resolution Using NAFNet},
+  booktitle = {CVPRW},
+  year      = {2022},
+}
+'''
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from basicsr.models.archs.NAFNet_arch import LayerNorm2d, NAFBlock
+from basicsr.models.archs.arch_util import MySequential
+from basicsr.models.archs.local_arch import Local_Base
+
+class SCAM(nn.Module):
+    '''
+    Stereo Cross Attention Module (SCAM)
+    '''
+    def __init__(self, c):
+        super().__init__()
+        self.scale = c ** -0.5
+
+        self.norm_l = LayerNorm2d(c)
+        self.norm_r = LayerNorm2d(c)
+        self.l_proj1 = nn.Conv2d(c, c, kernel_size=1, stride=1, padding=0)
+        self.r_proj1 = nn.Conv2d(c, c, kernel_size=1, stride=1, padding=0)
+        
+        self.beta = nn.Parameter(torch.zeros((1, c, 1, 1)), requires_grad=True)
+        self.gamma = nn.Parameter(torch.zeros((1, c, 1, 1)), requires_grad=True)
+
+        self.l_proj2 = nn.Conv2d(c, c, kernel_size=1, stride=1, padding=0)
+        self.r_proj2 = nn.Conv2d(c, c, kernel_size=1, stride=1, padding=0)
+
+    def forward(self, x_l, x_r):
+        Q_l = self.l_proj1(self.norm_l(x_l)).permute(0, 2, 3, 1)  # B, H, W, c
+        Q_r_T = self.r_proj1(self.norm_r(x_r)).permute(0, 2, 1, 3) # B, H, c, W (transposed)
+
+        V_l = self.l_proj2(x_l).permute(0, 2, 3, 1)  # B, H, W, c
+        V_r = self.r_proj2(x_r).permute(0, 2, 3, 1)  # B, H, W, c
+
+        # (B, H, W, c) x (B, H, c, W) -> (B, H, W, W)
+        attention = torch.matmul(Q_l, Q_r_T) * self.scale
+
+        F_r2l = torch.matmul(torch.softmax(attention, dim=-1), V_r)  #B, H, W, c
+        F_l2r = torch.matmul(torch.softmax(attention.permute(0, 1, 3, 2), dim=-1), V_l) #B, H, W, c
+
+        # scale
+        F_r2l = F_r2l.permute(0, 3, 1, 2) * self.beta
+        F_l2r = F_l2r.permute(0, 3, 1, 2) * self.gamma
+        return x_l + F_r2l, x_r + F_l2r
+
+class DropPath(nn.Module):
+    def __init__(self, drop_rate, module):
+        super().__init__()
+        self.drop_rate = drop_rate
+        self.module = module
+
+    def forward(self, *feats):
+        if self.training and np.random.rand() < self.drop_rate:
+            return feats
+
+        new_feats = self.module(*feats)
+        factor = 1. / (1 - self.drop_rate) if self.training else 1.
+
+        if self.training and factor != 1.:
+            new_feats = tuple([x+factor*(new_x-x) for x, new_x in zip(feats, new_feats)])
+        return new_feats
+
+class NAFBlockSR(nn.Module):
+    '''
+    NAFBlock for Super-Resolution
+    '''
+    def __init__(self, c, fusion=False, drop_out_rate=0.):
+        super().__init__()
+        self.blk = NAFBlock(c, drop_out_rate=drop_out_rate)
+        self.fusion = SCAM(c) if fusion else None
+
+    def forward(self, *feats):
+        feats = tuple([self.blk(x) for x in feats])
+        if self.fusion:
+            feats = self.fusion(*feats)
+        return feats
+
+class NAFNetSR(nn.Module):
+    '''
+    NAFNet for Super-Resolution
+    '''
+    def __init__(self, up_scale=4, width=48, num_blks=16, img_channel=3, drop_path_rate=0., drop_out_rate=0., fusion_from=-1, fusion_to=-1, dual=False):
+        super().__init__()
+        self.dual = dual    # dual input for stereo SR (left view, right view)
+        self.intro = nn.Conv2d(in_channels=img_channel, out_channels=width, kernel_size=3, padding=1, stride=1, groups=1,
+                              bias=True)
+        self.body = MySequential(
+            *[DropPath(
+                drop_path_rate, 
+                NAFBlockSR(
+                    width, 
+                    fusion=(fusion_from <= i and i <= fusion_to), 
+                    drop_out_rate=drop_out_rate
+                )) for i in range(num_blks)]
+        )
+
+        self.up = nn.Sequential(
+            nn.Conv2d(in_channels=width, out_channels=img_channel * up_scale**2, kernel_size=3, padding=1, stride=1, groups=1, bias=True),
+            nn.PixelShuffle(up_scale)
+        )
+        self.up_scale = up_scale
+
+    def forward(self, inp):
+        inp_hr = F.interpolate(inp, scale_factor=self.up_scale, mode='bilinear')
+        if self.dual:
+            inp = inp.chunk(2, dim=1)
+        else:
+            inp = (inp, )
+        feats = [self.intro(x) for x in inp]
+        feats = self.body(*feats)
+        out = torch.cat([self.up(x) for x in feats], dim=1)
+        out = out + inp_hr
+        return out
+
+class NAFSSR(Local_Base, NAFNetSR):
+    def __init__(self, *args, train_size=(1, 6, 30, 90), fast_imp=False, fusion_from=-1, fusion_to=1000, **kwargs):
+        Local_Base.__init__(self)
+        NAFNetSR.__init__(self, *args, img_channel=3, fusion_from=fusion_from, fusion_to=fusion_to, dual=True, **kwargs)
+
+        N, C, H, W = train_size
+        base_size = (int(H * 1.5), int(W * 1.5))
+
+        self.eval()
+        with torch.no_grad():
+            self.convert(base_size=base_size, train_size=train_size, fast_imp=fast_imp)
+
+if __name__ == '__main__':
+    num_blks = 128
+    width = 128
+    droppath=0.1
+    train_size = (1, 6, 30, 90)
+
+    net = NAFSSR(up_scale=2,train_size=train_size, fast_imp=True, width=width, num_blks=num_blks, drop_path_rate=droppath)
+
+    inp_shape = (6, 64, 64)
+
+    from ptflops import get_model_complexity_info
+    FLOPS = 0
+    macs, params = get_model_complexity_info(net, inp_shape, verbose=False, print_per_layer_stat=True)
+
+    # params = float(params[:-4])
+    print(params)
+    macs = float(macs[:-4]) + FLOPS / 10 ** 9
+
+    print('mac', macs, params)
+
+    # from basicsr.models.archs.arch_util import measure_inference_speed
+    # net = net.cuda()
+    # data = torch.randn((1, 6, 128, 128)).cuda()
+    # measure_inference_speed(net, (data,))
+
+
+
+

NAFNet/basicsr/models/archs/__init__.py

@@ -0,0 +1,52 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+import importlib
+from os import path as osp
+
+from basicsr.utils import scandir
+
+# automatically scan and import arch modules
+# 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.models.archs.{file_name}')
+    for file_name in arch_filenames
+]
+
+
+def dynamic_instantiation(modules, cls_type, opt):
+    """Dynamically instantiate class.
+
+    Args:
+        modules (list[importlib modules]): List of modules from importlib
+            files.
+        cls_type (str): Class type.
+        opt (dict): Class initialization kwargs.
+
+    Returns:
+        class: Instantiated class.
+    """
+
+    for module in modules:
+        cls_ = getattr(module, cls_type, None)
+        if cls_ is not None:
+            break
+    if cls_ is None:
+        raise ValueError(f'{cls_type} is not found.')
+    return cls_(**opt)
+
+
+def define_network(opt):
+    network_type = opt.pop('type')
+    net = dynamic_instantiation(_arch_modules, network_type, opt)
+    return net

NAFNet/basicsr/models/archs/arch_util.py

@@ -0,0 +1,350 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+import math
+import torch
+from torch import nn as nn
+from torch.nn import functional as F
+from torch.nn import init as init
+from torch.nn.modules.batchnorm import _BatchNorm
+
+from basicsr.utils import get_root_logger
+
+# try:
+#     from basicsr.models.ops.dcn import (ModulatedDeformConvPack,
+#                                         modulated_deform_conv)
+# except ImportError:
+#     # print('Cannot import dcn. Ignore this warning if dcn is not used. '
+#     #       'Otherwise install BasicSR with compiling dcn.')
+#
+
+@torch.no_grad()
+def default_init_weights(module_list, scale=1, bias_fill=0, **kwargs):
+    """Initialize network weights.
+
+    Args:
+        module_list (list[nn.Module] | nn.Module): Modules to be initialized.
+        scale (float): Scale initialized weights, especially for residual
+            blocks. Default: 1.
+        bias_fill (float): The value to fill bias. Default: 0
+        kwargs (dict): Other arguments for initialization function.
+    """
+    if not isinstance(module_list, list):
+        module_list = [module_list]
+    for module in module_list:
+        for m in module.modules():
+            if isinstance(m, nn.Conv2d):
+                init.kaiming_normal_(m.weight, **kwargs)
+                m.weight.data *= scale
+                if m.bias is not None:
+                    m.bias.data.fill_(bias_fill)
+            elif isinstance(m, nn.Linear):
+                init.kaiming_normal_(m.weight, **kwargs)
+                m.weight.data *= scale
+                if m.bias is not None:
+                    m.bias.data.fill_(bias_fill)
+            elif isinstance(m, _BatchNorm):
+                init.constant_(m.weight, 1)
+                if m.bias is not None:
+                    m.bias.data.fill_(bias_fill)
+
+
+def make_layer(basic_block, num_basic_block, **kwarg):
+    """Make layers by stacking the same blocks.
+
+    Args:
+        basic_block (nn.module): nn.module class for basic block.
+        num_basic_block (int): number of blocks.
+
+    Returns:
+        nn.Sequential: Stacked blocks in nn.Sequential.
+    """
+    layers = []
+    for _ in range(num_basic_block):
+        layers.append(basic_block(**kwarg))
+    return nn.Sequential(*layers)
+
+
+class ResidualBlockNoBN(nn.Module):
+    """Residual block without BN.
+
+    It has a style of:
+        ---Conv-ReLU-Conv-+-
+         |________________|
+
+    Args:
+        num_feat (int): Channel number of intermediate features.
+            Default: 64.
+        res_scale (float): Residual scale. Default: 1.
+        pytorch_init (bool): If set to True, use pytorch default init,
+            otherwise, use default_init_weights. Default: False.
+    """
+
+    def __init__(self, num_feat=64, res_scale=1, pytorch_init=False):
+        super(ResidualBlockNoBN, self).__init__()
+        self.res_scale = res_scale
+        self.conv1 = nn.Conv2d(num_feat, num_feat, 3, 1, 1, bias=True)
+        self.conv2 = nn.Conv2d(num_feat, num_feat, 3, 1, 1, bias=True)
+        self.relu = nn.ReLU(inplace=True)
+
+        if not pytorch_init:
+            default_init_weights([self.conv1, self.conv2], 0.1)
+
+    def forward(self, x):
+        identity = x
+        out = self.conv2(self.relu(self.conv1(x)))
+        return identity + out * self.res_scale
+
+
+class Upsample(nn.Sequential):
+    """Upsample module.
+
+    Args:
+        scale (int): Scale factor. Supported scales: 2^n and 3.
+        num_feat (int): Channel number of intermediate features.
+    """
+
+    def __init__(self, scale, num_feat):
+        m = []
+        if (scale & (scale - 1)) == 0:  # scale = 2^n
+            for _ in range(int(math.log(scale, 2))):
+                m.append(nn.Conv2d(num_feat, 4 * num_feat, 3, 1, 1))
+                m.append(nn.PixelShuffle(2))
+        elif scale == 3:
+            m.append(nn.Conv2d(num_feat, 9 * num_feat, 3, 1, 1))
+            m.append(nn.PixelShuffle(3))
+        else:
+            raise ValueError(f'scale {scale} is not supported. '
+                             'Supported scales: 2^n and 3.')
+        super(Upsample, self).__init__(*m)
+
+
+def flow_warp(x,
+              flow,
+              interp_mode='bilinear',
+              padding_mode='zeros',
+              align_corners=True):
+    """Warp an image or feature map with optical flow.
+
+    Args:
+        x (Tensor): Tensor with size (n, c, h, w).
+        flow (Tensor): Tensor with size (n, h, w, 2), normal value.
+        interp_mode (str): 'nearest' or 'bilinear'. Default: 'bilinear'.
+        padding_mode (str): 'zeros' or 'border' or 'reflection'.
+            Default: 'zeros'.
+        align_corners (bool): Before pytorch 1.3, the default value is
+            align_corners=True. After pytorch 1.3, the default value is
+            align_corners=False. Here, we use the True as default.
+
+    Returns:
+        Tensor: Warped image or feature map.
+    """
+    assert x.size()[-2:] == flow.size()[1:3]
+    _, _, h, w = x.size()
+    # create mesh grid
+    grid_y, grid_x = torch.meshgrid(
+        torch.arange(0, h).type_as(x),
+        torch.arange(0, w).type_as(x))
+    grid = torch.stack((grid_x, grid_y), 2).float()  # W(x), H(y), 2
+    grid.requires_grad = False
+
+    vgrid = grid + flow
+    # scale grid to [-1,1]
+    vgrid_x = 2.0 * vgrid[:, :, :, 0] / max(w - 1, 1) - 1.0
+    vgrid_y = 2.0 * vgrid[:, :, :, 1] / max(h - 1, 1) - 1.0
+    vgrid_scaled = torch.stack((vgrid_x, vgrid_y), dim=3)
+    output = F.grid_sample(
+        x,
+        vgrid_scaled,
+        mode=interp_mode,
+        padding_mode=padding_mode,
+        align_corners=align_corners)
+
+    # TODO, what if align_corners=False
+    return output
+
+
+def resize_flow(flow,
+                size_type,
+                sizes,
+                interp_mode='bilinear',
+                align_corners=False):
+    """Resize a flow according to ratio or shape.
+
+    Args:
+        flow (Tensor): Precomputed flow. shape [N, 2, H, W].
+        size_type (str): 'ratio' or 'shape'.
+        sizes (list[int | float]): the ratio for resizing or the final output
+            shape.
+            1) The order of ratio should be [ratio_h, ratio_w]. For
+            downsampling, the ratio should be smaller than 1.0 (i.e., ratio
+            < 1.0). For upsampling, the ratio should be larger than 1.0 (i.e.,
+            ratio > 1.0).
+            2) The order of output_size should be [out_h, out_w].
+        interp_mode (str): The mode of interpolation for resizing.
+            Default: 'bilinear'.
+        align_corners (bool): Whether align corners. Default: False.
+
+    Returns:
+        Tensor: Resized flow.
+    """
+    _, _, flow_h, flow_w = flow.size()
+    if size_type == 'ratio':
+        output_h, output_w = int(flow_h * sizes[0]), int(flow_w * sizes[1])
+    elif size_type == 'shape':
+        output_h, output_w = sizes[0], sizes[1]
+    else:
+        raise ValueError(
+            f'Size type should be ratio or shape, but got type {size_type}.')
+
+    input_flow = flow.clone()
+    ratio_h = output_h / flow_h
+    ratio_w = output_w / flow_w
+    input_flow[:, 0, :, :] *= ratio_w
+    input_flow[:, 1, :, :] *= ratio_h
+    resized_flow = F.interpolate(
+        input=input_flow,
+        size=(output_h, output_w),
+        mode=interp_mode,
+        align_corners=align_corners)
+    return resized_flow
+
+
+# TODO: may write a cpp file
+def pixel_unshuffle(x, scale):
+    """ Pixel unshuffle.
+
+    Args:
+        x (Tensor): Input feature with shape (b, c, hh, hw).
+        scale (int): Downsample ratio.
+
+    Returns:
+        Tensor: the pixel unshuffled feature.
+    """
+    b, c, hh, hw = x.size()
+    out_channel = c * (scale**2)
+    assert hh % scale == 0 and hw % scale == 0
+    h = hh // scale
+    w = hw // scale
+    x_view = x.view(b, c, h, scale, w, scale)
+    return x_view.permute(0, 1, 3, 5, 2, 4).reshape(b, out_channel, h, w)
+
+
+# class DCNv2Pack(ModulatedDeformConvPack):
+#     """Modulated deformable conv for deformable alignment.
+#
+#     Different from the official DCNv2Pack, which generates offsets and masks
+#     from the preceding features, this DCNv2Pack takes another different
+#     features to generate offsets and masks.
+#
+#     Ref:
+#         Delving Deep into Deformable Alignment in Video Super-Resolution.
+#     """
+#
+#     def forward(self, x, feat):
+#         out = self.conv_offset(feat)
+#         o1, o2, mask = torch.chunk(out, 3, dim=1)
+#         offset = torch.cat((o1, o2), dim=1)
+#         mask = torch.sigmoid(mask)
+#
+#         offset_absmean = torch.mean(torch.abs(offset))
+#         if offset_absmean > 50:
+#             logger = get_root_logger()
+#             logger.warning(
+#                 f'Offset abs mean is {offset_absmean}, larger than 50.')
+#
+#         return modulated_deform_conv(x, offset, mask, self.weight, self.bias,
+#                                      self.stride, self.padding, self.dilation,
+#                                      self.groups, self.deformable_groups)
+
+
+class LayerNormFunction(torch.autograd.Function):
+
+    @staticmethod
+    def forward(ctx, x, weight, bias, eps):
+        ctx.eps = eps
+        N, C, H, W = x.size()
+        mu = x.mean(1, keepdim=True)
+        var = (x - mu).pow(2).mean(1, keepdim=True)
+        y = (x - mu) / (var + eps).sqrt()
+        ctx.save_for_backward(y, var, weight)
+        y = weight.view(1, C, 1, 1) * y + bias.view(1, C, 1, 1)
+        return y
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        eps = ctx.eps
+
+        N, C, H, W = grad_output.size()
+        y, var, weight = ctx.saved_variables
+        g = grad_output * weight.view(1, C, 1, 1)
+        mean_g = g.mean(dim=1, keepdim=True)
+
+        mean_gy = (g * y).mean(dim=1, keepdim=True)
+        gx = 1. / torch.sqrt(var + eps) * (g - y * mean_gy - mean_g)
+        return gx, (grad_output * y).sum(dim=3).sum(dim=2).sum(dim=0), grad_output.sum(dim=3).sum(dim=2).sum(
+            dim=0), None
+
+class LayerNorm2d(nn.Module):
+
+    def __init__(self, channels, eps=1e-6):
+        super(LayerNorm2d, self).__init__()
+        self.register_parameter('weight', nn.Parameter(torch.ones(channels)))
+        self.register_parameter('bias', nn.Parameter(torch.zeros(channels)))
+        self.eps = eps
+
+    def forward(self, x):
+        return LayerNormFunction.apply(x, self.weight, self.bias, self.eps)
+
+# handle multiple input
+class MySequential(nn.Sequential):
+    def forward(self, *inputs):
+        for module in self._modules.values():
+            if type(inputs) == tuple:
+                inputs = module(*inputs)
+            else:
+                inputs = module(inputs)
+        return inputs
+
+import time
+def measure_inference_speed(model, data, max_iter=200, log_interval=50):
+    model.eval()
+
+    # the first several iterations may be very slow so skip them
+    num_warmup = 5
+    pure_inf_time = 0
+    fps = 0
+
+    # benchmark with 2000 image and take the average
+    for i in range(max_iter):
+
+        torch.cuda.synchronize()
+        start_time = time.perf_counter()
+
+        with torch.no_grad():
+            model(*data)
+
+        torch.cuda.synchronize()
+        elapsed = time.perf_counter() - start_time
+
+        if i >= num_warmup:
+            pure_inf_time += elapsed
+            if (i + 1) % log_interval == 0:
+                fps = (i + 1 - num_warmup) / pure_inf_time
+                print(
+                    f'Done image [{i + 1:<3}/ {max_iter}], '
+                    f'fps: {fps:.1f} img / s, '
+                    f'times per image: {1000 / fps:.1f} ms / img',
+                    flush=True)
+
+        if (i + 1) == max_iter:
+            fps = (i + 1 - num_warmup) / pure_inf_time
+            print(
+                f'Overall fps: {fps:.1f} img / s, '
+                f'times per image: {1000 / fps:.1f} ms / img',
+                flush=True)
+            break
+    return fps

NAFNet/basicsr/models/archs/local_arch.py

@@ -0,0 +1,104 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class AvgPool2d(nn.Module):
+    def __init__(self, kernel_size=None, base_size=None, auto_pad=True, fast_imp=False, train_size=None):
+        super().__init__()
+        self.kernel_size = kernel_size
+        self.base_size = base_size
+        self.auto_pad = auto_pad
+
+        # only used for fast implementation
+        self.fast_imp = fast_imp
+        self.rs = [5, 4, 3, 2, 1]
+        self.max_r1 = self.rs[0]
+        self.max_r2 = self.rs[0]
+        self.train_size = train_size
+
+    def extra_repr(self) -> str:
+        return 'kernel_size={}, base_size={}, stride={}, fast_imp={}'.format(
+            self.kernel_size, self.base_size, self.kernel_size, self.fast_imp
+        )
+
+    def forward(self, x):
+        if self.kernel_size is None and self.base_size:
+            train_size = self.train_size
+            if isinstance(self.base_size, int):
+                self.base_size = (self.base_size, self.base_size)
+            self.kernel_size = list(self.base_size)
+            self.kernel_size[0] = x.shape[2] * self.base_size[0] // train_size[-2]
+            self.kernel_size[1] = x.shape[3] * self.base_size[1] // train_size[-1]
+
+            # only used for fast implementation
+            self.max_r1 = max(1, self.rs[0] * x.shape[2] // train_size[-2])
+            self.max_r2 = max(1, self.rs[0] * x.shape[3] // train_size[-1])
+
+        if self.kernel_size[0] >= x.size(-2) and self.kernel_size[1] >= x.size(-1):
+            return F.adaptive_avg_pool2d(x, 1)
+
+        if self.fast_imp:  # Non-equivalent implementation but faster
+            h, w = x.shape[2:]
+            if self.kernel_size[0] >= h and self.kernel_size[1] >= w:
+                out = F.adaptive_avg_pool2d(x, 1)
+            else:
+                r1 = [r for r in self.rs if h % r == 0][0]
+                r2 = [r for r in self.rs if w % r == 0][0]
+                # reduction_constraint
+                r1 = min(self.max_r1, r1)
+                r2 = min(self.max_r2, r2)
+                s = x[:, :, ::r1, ::r2].cumsum(dim=-1).cumsum(dim=-2)
+                n, c, h, w = s.shape
+                k1, k2 = min(h - 1, self.kernel_size[0] // r1), min(w - 1, self.kernel_size[1] // r2)
+                out = (s[:, :, :-k1, :-k2] - s[:, :, :-k1, k2:] - s[:, :, k1:, :-k2] + s[:, :, k1:, k2:]) / (k1 * k2)
+                out = torch.nn.functional.interpolate(out, scale_factor=(r1, r2))
+        else:
+            n, c, h, w = x.shape
+            s = x.cumsum(dim=-1).cumsum_(dim=-2)
+            s = torch.nn.functional.pad(s, (1, 0, 1, 0))  # pad 0 for convenience
+            k1, k2 = min(h, self.kernel_size[0]), min(w, self.kernel_size[1])
+            s1, s2, s3, s4 = s[:, :, :-k1, :-k2], s[:, :, :-k1, k2:], s[:, :, k1:, :-k2], s[:, :, k1:, k2:]
+            out = s4 + s1 - s2 - s3
+            out = out / (k1 * k2)
+
+        if self.auto_pad:
+            n, c, h, w = x.shape
+            _h, _w = out.shape[2:]
+            # print(x.shape, self.kernel_size)
+            pad2d = ((w - _w) // 2, (w - _w + 1) // 2, (h - _h) // 2, (h - _h + 1) // 2)
+            out = torch.nn.functional.pad(out, pad2d, mode='replicate')
+
+        return out
+
+def replace_layers(model, base_size, train_size, fast_imp, **kwargs):
+    for n, m in model.named_children():
+        if len(list(m.children())) > 0:
+            ## compound module, go inside it
+            replace_layers(m, base_size, train_size, fast_imp, **kwargs)
+
+        if isinstance(m, nn.AdaptiveAvgPool2d):
+            pool = AvgPool2d(base_size=base_size, fast_imp=fast_imp, train_size=train_size)
+            assert m.output_size == 1
+            setattr(model, n, pool)
+
+
+'''
+ref. 
+@article{chu2021tlsc,
+  title={Revisiting Global Statistics Aggregation for Improving Image Restoration},
+  author={Chu, Xiaojie and Chen, Liangyu and and Chen, Chengpeng and Lu, Xin},
+  journal={arXiv preprint arXiv:2112.04491},
+  year={2021}
+}
+'''
+class Local_Base():
+    def convert(self, *args, train_size, **kwargs):
+        replace_layers(self, *args, train_size=train_size, **kwargs)
+        imgs = torch.rand(train_size)
+        with torch.no_grad():
+            self.forward(imgs)

NAFNet/basicsr/models/base_model.py

@@ -0,0 +1,356 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+import logging
+import os
+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.dist_util import master_only
+
+logger = logging.getLogger('basicsr')
+
+
+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, rgb2bgr=True, use_image=True):
+        """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.
+            rgb2bgr (bool): Whether to save images using rgb2bgr. Default: True
+            use_image (bool): Whether to use saved images to compute metrics (PSNR, SSIM), if not, then use data directly from network' output. Default: True
+        """
+        if self.opt['dist']:
+            return self.dist_validation(dataloader, current_iter, tb_logger, save_img, rgb2bgr, use_image)
+        else:
+            return self.nondist_validation(dataloader, current_iter, tb_logger,
+                                    save_img, rgb2bgr, use_image)
+
+    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 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']))
+        elif scheduler_type == 'TrueCosineAnnealingLR':
+            print('..', 'cosineannealingLR')
+            for optimizer in self.optimizers:
+                self.schedulers.append(
+                    torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, **train_opt['scheduler']))
+        elif scheduler_type == 'LinearLR':
+            for optimizer in self.optimizers:
+                self.schedulers.append(
+                    lr_scheduler.LinearLR(
+                        optimizer, train_opt['total_iter']))
+        elif scheduler_type == 'VibrateLR':
+            for optimizer in self.optimizers:
+                self.schedulers.append(
+                    lr_scheduler.VibrateLR(
+                        optimizer, train_opt['total_iter']))
+        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__} - '
+                           f'{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.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
+
+        torch.save(save_dict, save_path)
+
+    def _print_different_keys_loading(self, crt_net, load_net, strict=True):
+        """Print keys with differnet name or different size when loading models.
+
+        1. Print keys with differnet 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())
+
+        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'.
+        """
+        net = self.get_bare_model(net)
+        logger.info(
+            f'Loading {net.__class__.__name__} model from {load_path}.')
+        load_net = torch.load(
+            load_path, map_location=lambda storage, loc: storage)
+        if param_key is not None:
+            load_net = load_net[param_key]
+        print(' load net keys', load_net.keys)
+        # 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)
+            torch.save(state, 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

NAFNet/basicsr/models/image_restoration_model.py

@@ -0,0 +1,413 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+import importlib
+import torch
+import torch.nn.functional as F
+from collections import OrderedDict
+from copy import deepcopy
+from os import path as osp
+from tqdm import tqdm
+
+from basicsr.models.archs import define_network
+from basicsr.models.base_model import BaseModel
+from basicsr.utils import get_root_logger, imwrite, tensor2img
+from basicsr.utils.dist_util import get_dist_info
+
+loss_module = importlib.import_module('basicsr.models.losses')
+metric_module = importlib.import_module('basicsr.metrics')
+
+class ImageRestorationModel(BaseModel):
+    """Base Deblur model for single image deblur."""
+
+    def __init__(self, opt):
+        super(ImageRestorationModel, self).__init__(opt)
+
+        # define network
+        self.net_g = define_network(deepcopy(opt['network_g']))
+        self.net_g = self.model_to_device(self.net_g)
+
+        # load pretrained models
+        load_path = self.opt['path'].get('pretrain_network_g', None)
+        if load_path is not None:
+            self.load_network(self.net_g, load_path,
+                              self.opt['path'].get('strict_load_g', True), param_key=self.opt['path'].get('param_key', 'params'))
+
+        if self.is_train:
+            self.init_training_settings()
+
+        self.scale = int(opt['scale'])
+
+    def init_training_settings(self):
+        self.net_g.train()
+        train_opt = self.opt['train']
+
+        # define losses
+        if train_opt.get('pixel_opt'):
+            pixel_type = train_opt['pixel_opt'].pop('type')
+            cri_pix_cls = getattr(loss_module, pixel_type)
+            self.cri_pix = cri_pix_cls(**train_opt['pixel_opt']).to(
+                self.device)
+        else:
+            self.cri_pix = None
+
+        if train_opt.get('perceptual_opt'):
+            percep_type = train_opt['perceptual_opt'].pop('type')
+            cri_perceptual_cls = getattr(loss_module, percep_type)
+            self.cri_perceptual = cri_perceptual_cls(
+                **train_opt['perceptual_opt']).to(self.device)
+        else:
+            self.cri_perceptual = None
+
+        if self.cri_pix is None and self.cri_perceptual is None:
+            raise ValueError('Both pixel and perceptual losses are None.')
+
+        # set up optimizers and schedulers
+        self.setup_optimizers()
+        self.setup_schedulers()
+
+    def setup_optimizers(self):
+        train_opt = self.opt['train']
+        optim_params = []
+
+        for k, v in self.net_g.named_parameters():
+            if v.requires_grad:
+        #         if k.startswith('module.offsets') or k.startswith('module.dcns'):
+        #             optim_params_lowlr.append(v)
+        #         else:
+                optim_params.append(v)
+            # else:
+            #     logger = get_root_logger()
+            #     logger.warning(f'Params {k} will not be optimized.')
+        # print(optim_params)
+        # ratio = 0.1
+
+        optim_type = train_opt['optim_g'].pop('type')
+        if optim_type == 'Adam':
+            self.optimizer_g = torch.optim.Adam([{'params': optim_params}],
+                                                **train_opt['optim_g'])
+        elif optim_type == 'SGD':
+            self.optimizer_g = torch.optim.SGD(optim_params,
+                                               **train_opt['optim_g'])
+        elif optim_type == 'AdamW':
+            self.optimizer_g = torch.optim.AdamW([{'params': optim_params}],
+                                                **train_opt['optim_g'])
+            pass
+        else:
+            raise NotImplementedError(
+                f'optimizer {optim_type} is not supperted yet.')
+        self.optimizers.append(self.optimizer_g)
+
+    def feed_data(self, data, is_val=False):
+        self.lq = data['lq'].to(self.device)
+        if 'gt' in data:
+            self.gt = data['gt'].to(self.device)
+
+    def grids(self):
+        b, c, h, w = self.gt.size()
+        self.original_size = (b, c, h, w)
+
+        assert b == 1
+        if 'crop_size_h' in self.opt['val']:
+            crop_size_h = self.opt['val']['crop_size_h']
+        else:
+            crop_size_h = int(self.opt['val'].get('crop_size_h_ratio') * h)
+
+        if 'crop_size_w' in self.opt['val']:
+            crop_size_w = self.opt['val'].get('crop_size_w')
+        else:
+            crop_size_w = int(self.opt['val'].get('crop_size_w_ratio') * w)
+
+
+        crop_size_h, crop_size_w = crop_size_h // self.scale * self.scale, crop_size_w // self.scale * self.scale
+        #adaptive step_i, step_j
+        num_row = (h - 1) // crop_size_h + 1
+        num_col = (w - 1) // crop_size_w + 1
+
+        import math
+        step_j = crop_size_w if num_col == 1 else math.ceil((w - crop_size_w) / (num_col - 1) - 1e-8)
+        step_i = crop_size_h if num_row == 1 else math.ceil((h - crop_size_h) / (num_row - 1) - 1e-8)
+
+        scale = self.scale
+        step_i = step_i//scale*scale
+        step_j = step_j//scale*scale
+
+        parts = []
+        idxes = []
+
+        i = 0  # 0~h-1
+        last_i = False
+        while i < h and not last_i:
+            j = 0
+            if i + crop_size_h >= h:
+                i = h - crop_size_h
+                last_i = True
+
+            last_j = False
+            while j < w and not last_j:
+                if j + crop_size_w >= w:
+                    j = w - crop_size_w
+                    last_j = True
+                parts.append(self.lq[:, :, i // scale :(i + crop_size_h) // scale, j // scale:(j + crop_size_w) // scale])
+                idxes.append({'i': i, 'j': j})
+                j = j + step_j
+            i = i + step_i
+
+        self.origin_lq = self.lq
+        self.lq = torch.cat(parts, dim=0)
+        self.idxes = idxes
+
+    def grids_inverse(self):
+        preds = torch.zeros(self.original_size)
+        b, c, h, w = self.original_size
+
+        count_mt = torch.zeros((b, 1, h, w))
+        if 'crop_size_h' in self.opt['val']:
+            crop_size_h = self.opt['val']['crop_size_h']
+        else:
+            crop_size_h = int(self.opt['val'].get('crop_size_h_ratio') * h)
+
+        if 'crop_size_w' in self.opt['val']:
+            crop_size_w = self.opt['val'].get('crop_size_w')
+        else:
+            crop_size_w = int(self.opt['val'].get('crop_size_w_ratio') * w)
+
+        crop_size_h, crop_size_w = crop_size_h // self.scale * self.scale, crop_size_w // self.scale * self.scale
+
+        for cnt, each_idx in enumerate(self.idxes):
+            i = each_idx['i']
+            j = each_idx['j']
+            preds[0, :, i: i + crop_size_h, j: j + crop_size_w] += self.outs[cnt]
+            count_mt[0, 0, i: i + crop_size_h, j: j + crop_size_w] += 1.
+
+        self.output = (preds / count_mt).to(self.device)
+        self.lq = self.origin_lq
+
+    def optimize_parameters(self, current_iter, tb_logger):
+        self.optimizer_g.zero_grad()
+
+        if self.opt['train'].get('mixup', False):
+            self.mixup_aug()
+
+        preds = self.net_g(self.lq)
+        if not isinstance(preds, list):
+            preds = [preds]
+
+        self.output = preds[-1]
+
+        l_total = 0
+        loss_dict = OrderedDict()
+        # pixel loss
+        if self.cri_pix:
+            l_pix = 0.
+            for pred in preds:
+                l_pix += self.cri_pix(pred, self.gt)
+
+            # print('l pix ... ', l_pix)
+            l_total += l_pix
+            loss_dict['l_pix'] = l_pix
+
+        # perceptual loss
+        if self.cri_perceptual:
+            l_percep, l_style = self.cri_perceptual(self.output, self.gt)
+        #
+            if l_percep is not None:
+                l_total += l_percep
+                loss_dict['l_percep'] = l_percep
+            if l_style is not None:
+                l_total += l_style
+                loss_dict['l_style'] = l_style
+
+
+        l_total = l_total + 0. * sum(p.sum() for p in self.net_g.parameters())
+
+        l_total.backward()
+        use_grad_clip = self.opt['train'].get('use_grad_clip', True)
+        if use_grad_clip:
+            torch.nn.utils.clip_grad_norm_(self.net_g.parameters(), 0.01)
+        self.optimizer_g.step()
+
+
+        self.log_dict = self.reduce_loss_dict(loss_dict)
+
+    def test(self):
+        self.net_g.eval()
+        with torch.no_grad():
+            n = len(self.lq)
+            outs = []
+            m = self.opt['val'].get('max_minibatch', n)
+            i = 0
+            while i < n:
+                j = i + m
+                if j >= n:
+                    j = n
+                pred = self.net_g(self.lq[i:j])
+                if isinstance(pred, list):
+                    pred = pred[-1]
+                outs.append(pred.detach().cpu())
+                i = j
+
+            self.output = torch.cat(outs, dim=0)
+        self.net_g.train()
+
+    def dist_validation(self, dataloader, current_iter, tb_logger, save_img, rgb2bgr, use_image):
+        dataset_name = dataloader.dataset.opt['name']
+        with_metrics = self.opt['val'].get('metrics') is not None
+        if with_metrics:
+            self.metric_results = {
+                metric: 0
+                for metric in self.opt['val']['metrics'].keys()
+            }
+
+        rank, world_size = get_dist_info()
+        if rank == 0:
+            pbar = tqdm(total=len(dataloader), unit='image')
+
+        cnt = 0
+
+        for idx, val_data in enumerate(dataloader):
+            if idx % world_size != rank:
+                continue
+
+            img_name = osp.splitext(osp.basename(val_data['lq_path'][0]))[0]
+
+            self.feed_data(val_data, is_val=True)
+            if self.opt['val'].get('grids', False):
+                self.grids()
+
+            self.test()
+
+            if self.opt['val'].get('grids', False):
+                self.grids_inverse()
+
+            visuals = self.get_current_visuals()
+            sr_img = tensor2img([visuals['result']], rgb2bgr=rgb2bgr)
+            if 'gt' in visuals:
+                gt_img = tensor2img([visuals['gt']], rgb2bgr=rgb2bgr)
+                del self.gt
+
+            # tentative for out of GPU memory
+            del self.lq
+            del self.output
+            torch.cuda.empty_cache()
+
+            if save_img:
+                if sr_img.shape[2] == 6:
+                    L_img = sr_img[:, :, :3]
+                    R_img = sr_img[:, :, 3:]
+
+                    # visual_dir = osp.join('visual_results', dataset_name, self.opt['name'])
+                    visual_dir = osp.join(self.opt['path']['visualization'], dataset_name)
+
+                    imwrite(L_img, osp.join(visual_dir, f'{img_name}_L.png'))
+                    imwrite(R_img, osp.join(visual_dir, f'{img_name}_R.png'))
+                else:
+                    if self.opt['is_train']:
+
+                        save_img_path = osp.join(self.opt['path']['visualization'],
+                                                 img_name,
+                                                 f'{img_name}_{current_iter}.png')
+
+                        save_gt_img_path = osp.join(self.opt['path']['visualization'],
+                                                 img_name,
+                                                 f'{img_name}_{current_iter}_gt.png')
+                    else:
+                        save_img_path = osp.join(
+                            self.opt['path']['visualization'], dataset_name,
+                            f'{img_name}.png')
+                        save_gt_img_path = osp.join(
+                            self.opt['path']['visualization'], dataset_name,
+                            f'{img_name}_gt.png')
+
+                    imwrite(sr_img, save_img_path)
+                    imwrite(gt_img, save_gt_img_path)
+
+            if with_metrics:
+                # calculate metrics
+                opt_metric = deepcopy(self.opt['val']['metrics'])
+                if use_image:
+                    for name, opt_ in opt_metric.items():
+                        metric_type = opt_.pop('type')
+                        self.metric_results[name] += getattr(
+                            metric_module, metric_type)(sr_img, gt_img, **opt_)
+                else:
+                    for name, opt_ in opt_metric.items():
+                        metric_type = opt_.pop('type')
+                        self.metric_results[name] += getattr(
+                            metric_module, metric_type)(visuals['result'], visuals['gt'], **opt_)
+
+            cnt += 1
+            if rank == 0:
+                for _ in range(world_size):
+                    pbar.update(1)
+                    pbar.set_description(f'Test {img_name}')
+        if rank == 0:
+            pbar.close()
+
+        # current_metric = 0.
+        collected_metrics = OrderedDict()
+        if with_metrics:
+            for metric in self.metric_results.keys():
+                collected_metrics[metric] = torch.tensor(self.metric_results[metric]).float().to(self.device)
+            collected_metrics['cnt'] = torch.tensor(cnt).float().to(self.device)
+
+            self.collected_metrics = collected_metrics
+        
+        keys = []
+        metrics = []
+        for name, value in self.collected_metrics.items():
+            keys.append(name)
+            metrics.append(value)
+        metrics = torch.stack(metrics, 0)
+        torch.distributed.reduce(metrics, dst=0)
+        if self.opt['rank'] == 0:
+            metrics_dict = {}
+            cnt = 0
+            for key, metric in zip(keys, metrics):
+                if key == 'cnt':
+                    cnt = float(metric)
+                    continue
+                metrics_dict[key] = float(metric)
+
+            for key in metrics_dict:
+                metrics_dict[key] /= cnt
+
+            self._log_validation_metric_values(current_iter, dataloader.dataset.opt['name'],
+                                               tb_logger, metrics_dict)
+        return 0.
+
+    def nondist_validation(self, *args, **kwargs):
+        logger = get_root_logger()
+        logger.warning('nondist_validation is not implemented. Run dist_validation.')
+        self.dist_validation(*args, **kwargs)
+
+
+    def _log_validation_metric_values(self, current_iter, dataset_name,
+                                      tb_logger, metric_dict):
+        log_str = f'Validation {dataset_name}, \t'
+        for metric, value in metric_dict.items():
+            log_str += f'\t # {metric}: {value:.4f}'
+        logger = get_root_logger()
+        logger.info(log_str)
+
+        log_dict = OrderedDict()
+        # for name, value in loss_dict.items():
+        for metric, value in metric_dict.items():
+            log_dict[f'm_{metric}'] = value
+
+        self.log_dict = log_dict
+
+    def get_current_visuals(self):
+        out_dict = OrderedDict()
+        out_dict['lq'] = self.lq.detach().cpu()
+        out_dict['result'] = self.output.detach().cpu()
+        if hasattr(self, 'gt'):
+            out_dict['gt'] = self.gt.detach().cpu()
+        return out_dict
+
+    def save(self, epoch, current_iter):
+        self.save_network(self.net_g, 'net_g', current_iter)
+        self.save_training_state(epoch, current_iter)

NAFNet/basicsr/models/losses/__init__.py

@@ -0,0 +1,11 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+from .losses import (L1Loss, MSELoss, PSNRLoss)
+
+__all__ = [
+    'L1Loss', 'MSELoss', 'PSNRLoss',
+]

NAFNet/basicsr/models/losses/loss_util.py

@@ -0,0 +1,101 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+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

NAFNet/basicsr/models/losses/losses.py

@@ -0,0 +1,116 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+import torch
+from torch import nn as nn
+from torch.nn import functional as F
+import numpy as np
+
+from basicsr.models.losses.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)
+
+
+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}. '
+                             f'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)
+
+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}. '
+                             f'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)
+
+class PSNRLoss(nn.Module):
+
+    def __init__(self, loss_weight=1.0, reduction='mean', toY=False):
+        super(PSNRLoss, self).__init__()
+        assert reduction == 'mean'
+        self.loss_weight = loss_weight
+        self.scale = 10 / np.log(10)
+        self.toY = toY
+        self.coef = torch.tensor([65.481, 128.553, 24.966]).reshape(1, 3, 1, 1)
+        self.first = True
+
+    def forward(self, pred, target):
+        assert len(pred.size()) == 4
+        if self.toY:
+            if self.first:
+                self.coef = self.coef.to(pred.device)
+                self.first = False
+
+            pred = (pred * self.coef).sum(dim=1).unsqueeze(dim=1) + 16.
+            target = (target * self.coef).sum(dim=1).unsqueeze(dim=1) + 16.
+
+            pred, target = pred / 255., target / 255.
+            pass
+        assert len(pred.size()) == 4
+
+        return self.loss_weight * self.scale * torch.log(((pred - target) ** 2).mean(dim=(1, 2, 3)) + 1e-8).mean()
+

NAFNet/basicsr/models/lr_scheduler.py

@@ -0,0 +1,189 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+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
+        ]
+
+class LinearLR(_LRScheduler):
+    """
+
+    Args:
+        optimizer (torch.nn.optimizer): Torch optimizer.
+        milestones (list): Iterations that will decrease learning rate.
+        gamma (float): Decrease ratio. Default: 0.1.
+        last_epoch (int): Used in _LRScheduler. Default: -1.
+    """
+
+    def __init__(self,
+                 optimizer,
+                 total_iter,
+                 last_epoch=-1):
+        self.total_iter = total_iter
+        super(LinearLR, self).__init__(optimizer, last_epoch)
+
+    def get_lr(self):
+        process = self.last_epoch / self.total_iter
+        weight = (1 - process)
+        # print('get lr ', [weight * group['initial_lr'] for group in self.optimizer.param_groups])
+        return [weight * group['initial_lr'] for group in self.optimizer.param_groups]
+
+class VibrateLR(_LRScheduler):
+    """
+
+    Args:
+        optimizer (torch.nn.optimizer): Torch optimizer.
+        milestones (list): Iterations that will decrease learning rate.
+        gamma (float): Decrease ratio. Default: 0.1.
+        last_epoch (int): Used in _LRScheduler. Default: -1.
+    """
+
+    def __init__(self,
+                 optimizer,
+                 total_iter,
+                 last_epoch=-1):
+        self.total_iter = total_iter
+        super(VibrateLR, self).__init__(optimizer, last_epoch)
+
+    def get_lr(self):
+        process = self.last_epoch / self.total_iter
+
+        f = 0.1
+        if process < 3 / 8:
+            f = 1 - process * 8 / 3
+        elif process < 5 / 8:
+            f = 0.2
+
+        T = self.total_iter // 80
+        Th = T // 2
+
+        t = self.last_epoch % T
+
+        f2 = t / Th
+        if t >= Th:
+            f2 = 2 - f2
+
+        weight = f * f2
+
+        if self.last_epoch < Th:
+            weight = max(0.1, weight)
+
+        # print('f {}, T {}, Th {}, t {}, f2 {}'.format(f, T, Th, t, f2))
+        return [weight * group['initial_lr'] 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 mimimum 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
+        ]

NAFNet/basicsr/test.py

@@ -0,0 +1,70 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+import logging
+import torch
+from os import path as osp
+
+from basicsr.data import create_dataloader, create_dataset
+from basicsr.models import create_model
+from basicsr.train import parse_options
+from basicsr.utils import (get_env_info, get_root_logger, get_time_str,
+                           make_exp_dirs)
+from basicsr.utils.options import dict2str
+
+
+def main():
+    # parse options, set distributed setting, set ramdom seed
+    opt = parse_options(is_train=False)
+
+    torch.backends.cudnn.benchmark = True
+    # torch.backends.cudnn.deterministic = True
+
+    # mkdir and initialize loggers
+    make_exp_dirs(opt)
+    log_file = osp.join(opt['path']['log'],
+                        f"test_{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))
+
+    # create test dataset and dataloader
+    test_loaders = []
+    for phase, dataset_opt in sorted(opt['datasets'].items()):
+        if 'test' in phase:
+            dataset_opt['phase'] = 'test'
+        test_set = create_dataset(dataset_opt)
+        test_loader = create_dataloader(
+            test_set,
+            dataset_opt,
+            num_gpu=opt['num_gpu'],
+            dist=opt['dist'],
+            sampler=None,
+            seed=opt['manual_seed'])
+        logger.info(
+            f"Number of test images in {dataset_opt['name']}: {len(test_set)}")
+        test_loaders.append(test_loader)
+
+    # create model
+    model = create_model(opt)
+
+    for test_loader in test_loaders:
+        test_set_name = test_loader.dataset.opt['name']
+        logger.info(f'Testing {test_set_name}...')
+        rgb2bgr = opt['val'].get('rgb2bgr', True)
+        # wheather use uint8 image to compute metrics
+        use_image = opt['val'].get('use_image', True)
+        model.validation(
+            test_loader,
+            current_iter=opt['name'],
+            tb_logger=None,
+            save_img=opt['val']['save_img'],
+            rgb2bgr=rgb2bgr, use_image=use_image)
+
+
+if __name__ == '__main__':
+    main()

NAFNet/basicsr/train.py

@@ -0,0 +1,305 @@
+# ------------------------------------------------------------------------
+# Copyright (c) 2022 megvii-model. All Rights Reserved.
+# ------------------------------------------------------------------------
+# Modified from BasicSR (https://github.com/xinntao/BasicSR)
+# Copyright 2018-2020 BasicSR Authors
+# ------------------------------------------------------------------------
+import argparse
+import datetime
+import logging
+import math
+import random
+import time
+import torch
+from os import path as osp
+
+from basicsr.data import create_dataloader, create_dataset
+from basicsr.data.data_sampler import EnlargedSampler
+from basicsr.data.prefetch_dataloader import CPUPrefetcher, CUDAPrefetcher
+from basicsr.models import create_model
+from basicsr.utils import (MessageLogger, check_resume, get_env_info,
+                           get_root_logger, get_time_str, init_tb_logger,
+                           init_wandb_logger, make_exp_dirs, mkdir_and_rename,
+                           set_random_seed)
+from basicsr.utils.dist_util import get_dist_info, init_dist
+from basicsr.utils.options import dict2str, parse
+
+
+def parse_options(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('--local_rank', type=int, default=0)
+
+    parser.add_argument('--input_path', type=str, required=False, help='The path to the input image. For single image inference only.')
+    parser.add_argument('--output_path', type=str, required=False, help='The path to the output image. For single image inference only.')
+
+    args = parser.parse_args()
+    opt = parse(args.opt, is_train=is_train)
+
+    # 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)
+            print('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'])
+
+    if args.input_path is not None and args.output_path is not None:
+        opt['img_path'] = {
+            'input_img': args.input_path,
+            'output_img': args.output_path
+        }
+
+    return opt
+
+
+def init_loggers(opt):
+    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 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=f'./logs/{opt['name']}') #mkdir logs @CLY
+        tb_logger = init_tb_logger(log_dir=osp.join('logs', opt['name']))
+    return logger, tb_logger
+
+
+def create_train_val_dataloader(opt, logger):
+    # create train and val dataloaders
+    train_loader, val_loader = None, None
+    for phase, dataset_opt in opt['datasets'].items():
+        if phase == 'train':
+            dataset_enlarge_ratio = dataset_opt.get('dataset_enlarge_ratio', 1)
+            train_set = create_dataset(dataset_opt)
+            train_sampler = EnlargedSampler(train_set, opt['world_size'],
+                                            opt['rank'], dataset_enlarge_ratio)
+            train_loader = create_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 == 'val':
+            val_set = create_dataset(dataset_opt)
+            val_loader = create_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"]}: '
+                f'{len(val_set)}')
+        else:
+            raise ValueError(f'Dataset phase {phase} is not recognized.')
+
+    return train_loader, train_sampler, val_loader, total_epochs, total_iters
+
+
+def main():
+    # parse options, set distributed setting, set ramdom seed
+    opt = parse_options(is_train=True)
+
+    torch.backends.cudnn.benchmark = True
+    # torch.backends.cudnn.deterministic = True
+
+    # automatic resume ..
+    state_folder_path = 'experiments/{}/training_states/'.format(opt['name'])
+    import os
+    try:
+        states = os.listdir(state_folder_path)
+    except:
+        states = []
+
+    resume_state = None
+    if len(states) > 0:
+        print('!!!!!! resume state .. ', states, state_folder_path)
+        max_state_file = '{}.state'.format(max([int(x[0:-6]) for x in states]))
+        resume_state = os.path.join(state_folder_path, max_state_file)
+        opt['path']['resume_state'] = resume_state
+
+    # load resume states if necessary
+    if opt['path'].get('resume_state'):
+        device_id = torch.cuda.current_device()
+        resume_state = torch.load(
+            opt['path']['resume_state'],
+            map_location=lambda storage, loc: storage.cuda(device_id))
+    else:
+        resume_state = None
+
+    # 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('tb_logger', opt['name']))
+
+    # initialize loggers
+    logger, tb_logger = init_loggers(opt)
+
+    # create train and validation dataloaders
+    result = create_train_val_dataloader(opt, logger)
+    train_loader, train_sampler, val_loader, total_epochs, total_iters = result
+
+    # create model
+    if resume_state:  # resume training
+        check_resume(opt, resume_state['iter'])
+        model = create_model(opt)
+        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:
+        model = create_model(opt)
+        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_time, iter_time = time.time(), time.time()
+    start_time = time.time()
+
+    # for epoch in range(start_epoch, total_epochs + 1):
+    epoch = start_epoch
+    while current_iter <= total_iters:
+        train_sampler.set_epoch(epoch)
+        prefetcher.reset()
+        train_data = prefetcher.next()
+
+        while train_data is not None:
+            data_time = time.time() - data_time
+
+            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, is_val=False)
+            result_code = model.optimize_parameters(current_iter, tb_logger)
+            # if result_code == -1 and tb_logger:
+            #     print('loss explode .. ')
+            #     exit(0)
+            iter_time = time.time() - iter_time
+            # log
+            if current_iter % opt['logger']['print_freq'] == 0:
+                log_vars = {'epoch': epoch, 'iter': current_iter, 'total_iter': total_iters}
+                log_vars.update({'lrs': model.get_current_learning_rate()})
+                log_vars.update({'time': iter_time, 'data_time': data_time})
+                log_vars.update(model.get_current_log())
+                # print('msg logger .. ', current_iter)
+                msg_logger(log_vars)
+
+            # 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 or current_iter == 1000):
+            # if opt.get('val') is not None and (current_iter % opt['val']['val_freq'] == 0):
+                rgb2bgr = opt['val'].get('rgb2bgr', True)
+                # wheather use uint8 image to compute metrics
+                use_image = opt['val'].get('use_image', True)
+                model.validation(val_loader, current_iter, tb_logger,
+                                 opt['val']['save_img'], rgb2bgr, use_image )
+                log_vars = {'epoch': epoch, 'iter': current_iter, 'total_iter': total_iters}
+                log_vars.update({'lrs': model.get_current_learning_rate()})
+                log_vars.update(model.get_current_log())
+                msg_logger(log_vars)
+
+
+            data_time = time.time()
+            iter_time = time.time()
+            train_data = prefetcher.next()
+        # end of iter
+        epoch += 1
+
+    # 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:
+        rgb2bgr = opt['val'].get('rgb2bgr', True)
+        use_image = opt['val'].get('use_image', True)
+        metric = model.validation(val_loader, current_iter, tb_logger,
+                         opt['val']['save_img'], rgb2bgr, use_image)
+        # if tb_logger:
+        #     print('xxresult! ', opt['name'], ' ', metric)
+    if tb_logger:
+        tb_logger.close()
+
+
+if __name__ == '__main__':
+    import os
+    os.environ['GRPC_POLL_STRATEGY']='epoll1'
+    main()