delete unnecessary files

models/SRFlow/code/Measure.py

@@ -1,134 +0,0 @@
-# Copyright (c) 2020 Huawei Technologies Co., Ltd.
-# Licensed under CC BY-NC-SA 4.0 (Attribution-NonCommercial-ShareAlike 4.0 International) (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode
-#
-# The code is released for academic research use only. For commercial use, please contact Huawei Technologies Co., Ltd.
-# 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.
-
-import glob
-import os
-import time
-from collections import OrderedDict
-
-import numpy as np
-import torch
-import cv2
-import argparse
-
-from natsort import natsort
-from skimage.metrics import structural_similarity as ssim
-from skimage.metrics import peak_signal_noise_ratio as psnr
-import lpips
-
-
-class Measure():
-    def __init__(self, net='alex', use_gpu=False):
-        self.device = 'cuda' if use_gpu else 'cpu'
-        self.model = lpips.LPIPS(net=net)
-        self.model.to(self.device)
-
-    def measure(self, imgA, imgB):
-        return [float(f(imgA, imgB)) for f in [self.psnr, self.ssim, self.lpips]]
-
-    def lpips(self, imgA, imgB, model=None):
-        tA = t(imgA).to(self.device)
-        tB = t(imgB).to(self.device)
-        dist01 = self.model.forward(tA, tB).item()
-        return dist01
-
-    def ssim(self, imgA, imgB):
-        # multichannel: If True, treat the last dimension of the array as channels. Similarity calculations are done independently for each channel then averaged.
-        score, diff = ssim(imgA, imgB, full=True, multichannel=True, channel_axis=-1)
-        return score
-
-    def psnr(self, imgA, imgB):
-        psnr_val = psnr(imgA, imgB)
-        return psnr_val
-
-
-def t(img):
-    def to_4d(img):
-        assert len(img.shape) == 3
-        assert img.dtype == np.uint8
-        img_new = np.expand_dims(img, axis=0)
-        assert len(img_new.shape) == 4
-        return img_new
-
-    def to_CHW(img):
-        return np.transpose(img, [2, 0, 1])
-
-    def to_tensor(img):
-        return torch.Tensor(img)
-
-    return to_tensor(to_4d(to_CHW(img))) / 127.5 - 1
-
-
-def fiFindByWildcard(wildcard):
-    return natsort.natsorted(glob.glob(wildcard, recursive=True))
-
-
-def imread(path):
-    return cv2.imread(path)[:, :, [2, 1, 0]]
-
-
-def format_result(psnr, ssim, lpips):
-    return f'{psnr:0.2f}, {ssim:0.3f}, {lpips:0.3f}'
-
-def measure_dirs(dirA, dirB, use_gpu, verbose=False):
-    if verbose:
-        vprint = lambda x: print(x)
-    else:
-        vprint = lambda x: None
-
-
-    t_init = time.time()
-
-    paths_A = fiFindByWildcard(os.path.join(dirA, f'*.{type}'))
-    paths_B = fiFindByWildcard(os.path.join(dirB, f'*.{type}'))
-
-    vprint("Comparing: ")
-    vprint(dirA)
-    vprint(dirB)
-
-    measure = Measure(use_gpu=use_gpu)
-
-    results = []
-    for pathA, pathB in zip(paths_A, paths_B):
-        result = OrderedDict()
-
-        t = time.time()
-        result['psnr'], result['ssim'], result['lpips'] = measure.measure(imread(pathA), imread(pathB))
-        d = time.time() - t
-        vprint(f"{pathA.split('/')[-1]}, {pathB.split('/')[-1]}, {format_result(**result)}, {d:0.1f}")
-
-        results.append(result)
-
-    psnr = np.mean([result['psnr'] for result in results])
-    ssim = np.mean([result['ssim'] for result in results])
-    lpips = np.mean([result['lpips'] for result in results])
-
-    vprint(f"Final Result: {format_result(psnr, ssim, lpips)}, {time.time() - t_init:0.1f}s")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument('-dirA', default='', type=str)
-    parser.add_argument('-dirB', default='', type=str)
-    parser.add_argument('-type', default='png')
-    parser.add_argument('--use_gpu', action='store_true', default=False)
-    args = parser.parse_args()
-
-    dirA = args.dirA
-    dirB = args.dirB
-    type = args.type
-    use_gpu = args.use_gpu
-
-    if len(dirA) > 0 and len(dirB) > 0:
-        measure_dirs(dirA, dirB, use_gpu=use_gpu, verbose=True)

models/SRFlow/code/__init__.py

@@ -22,7 +22,6 @@ sys.path.append('../..')
 from natsort import natsort
 import SRFlow.code.options.options as option
 
-from SRFlow.code.models import create_model
 import torch
 from SRFlow.code.utils.util import opt_get
 from SRFlow.code.models.SRFlow_model import SRFlowModel

models/SRFlow/code/a.py

@@ -1,27 +0,0 @@
-import pickle
-import numpy as np
-import os
-import matplotlib.pyplot as plt
-
-def load_pkls(path):
-    assert os.path.isfile(path), path
-    images = []
-    with open(path, "rb") as f:
-        images += pickle.load(f)
-    assert len(images) > 0, path
-    images = [np.transpose(image, [2, 0, 1]) for image in images]
-    return images
-
-path = 'datasets/DIV2K-va.pklv4'
-loaded_images = load_pkls(path)
-print(len(loaded_images))
-# Display the first image
-if loaded_images:
-    first_image = loaded_images[11]
-    plt.imshow(np.transpose(first_image, [1, 2, 0]))  # Transpose image to original shape [height, width, channels]
-    plt.title('First Image')
-    plt.axis('off')  # Hide axis
-    plt.show()
-else:
-    print("No images loaded from the pickle file.")
-print(loaded_images[11])

models/SRFlow/code/confs/RRDB_CelebA_8X.yml

@@ -1,83 +0,0 @@
-# Copyright (c) 2020 Huawei Technologies Co., Ltd.
-# Licensed under CC BY-NC-SA 4.0 (Attribution-NonCommercial-ShareAlike 4.0 International) (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode
-#
-# The code is released for academic research use only. For commercial use, please contact Huawei Technologies Co., Ltd.
-# 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.
-#
-# This file contains content licensed by https://github.com/xinntao/BasicSR/blob/master/LICENSE/LICENSE
-
-#### general settings
-name: train
-use_tb_logger: true
-model: SR
-distortion: sr
-scale: 8
-#gpu_ids: [ 0 ]
-
-#### datasets
-datasets:
-  train:
-    name: CelebA_160_tr
-    mode: LRHR_PKL
-    dataroot_GT: ../datasets/celebA-train-gt_1pct.pklv4
-    dataroot_LQ: ../datasets/celebA-train-x8_1pct.pklv4
-
-    use_shuffle: true
-    n_workers: 0  # per GPU
-    batch_size: 16
-    GT_size: 160
-    use_flip: true
-    use_rot: true
-    color: RGB
-  val:
-    name: CelebA_160_va
-    mode: LRHR_PKL
-    dataroot_GT: ../datasets/celebA-valid-gt_1pct.pklv4
-    dataroot_LQ: ../datasets/celebA-valid-x8_1pct.pklv4
-    n_max: 10
-
-#### network structures
-network_G:
-  which_model_G: RRDBNet
-  in_nc: 3
-  out_nc: 3
-  nf: 64
-  nb: 23
-
-#### path
-path:
-  pretrain_model_G: ~
-  strict_load: true
-  resume_state: auto
-
-#### training settings: learning rate scheme, loss
-train:
-  lr_G: !!float 2e-4
-  lr_scheme: CosineAnnealingLR_Restart
-  beta1: 0.9
-  beta2: 0.99
-  niter: 200000
-  warmup_iter: -1  # no warm up
-  T_period: [ 50000, 50000, 50000, 50000 ]
-  restarts: [ 50000, 100000, 150000 ]
-  restart_weights: [ 1, 1, 1 ]
-  eta_min: !!float 1e-7
-
-  pixel_criterion: l1
-  pixel_weight: 1.0
-
-  manual_seed: 10
-  val_freq: !!float 5e3
-
-#### logger
-logger:
-  print_freq: 100
-  save_checkpoint_freq: !!float 1e3

models/SRFlow/code/confs/RRDB_DF2K_4X.yml

@@ -1,85 +0,0 @@
-# Copyright (c) 2020 Huawei Technologies Co., Ltd.
-# Licensed under CC BY-NC-SA 4.0 (Attribution-NonCommercial-ShareAlike 4.0 International) (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode
-#
-# The code is released for academic research use only. For commercial use, please contact Huawei Technologies Co., Ltd.
-# 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.
-#
-# This file contains content licensed by https://github.com/xinntao/BasicSR/blob/master/LICENSE/LICENSE
-
-#### general settings
-name: train
-use_tb_logger: true
-model: SR
-distortion: sr
-scale: 4
-gpu_ids: [ 0 ]
-
-#### datasets
-datasets:
-  train:
-    name: CelebA_160_tr
-    mode: LRHR_PKL
-    dataroot_GT: ../datasets/DF2K-train-gt_1pct.pklv4
-    dataroot_LQ: ../datasets/DF2K-train-x4_1pct.pklv4
-    quant: 32
-
-    use_shuffle: true
-    n_workers: 3  # per GPU
-    batch_size: 16
-    GT_size: 160
-    use_flip: true
-    color: RGB
-  val:
-    name: CelebA_160_va
-    mode: LRHR_PKL
-    dataroot_GT: ../datasets/DF2K-valid-gt_1pct.pklv4
-    dataroot_LQ: ../datasets/DF2K-valid-x4_1pct.pklv4
-    quant: 32
-    n_max: 20
-
-#### network structures
-network_G:
-  which_model_G: RRDBNet
-  use_orig: True
-  in_nc: 3
-  out_nc: 3
-  nf: 64
-  nb: 23
-
-#### path
-path:
-  pretrain_model_G: ~
-  strict_load: true
-  resume_state: auto
-
-#### training settings: learning rate scheme, loss
-train:
-  lr_G: !!float 2e-4
-  lr_scheme: CosineAnnealingLR_Restart
-  beta1: 0.9
-  beta2: 0.99
-  niter: 1000000
-  warmup_iter: -1  # no warm up
-  T_period: [ 50000, 50000, 50000, 50000 ]
-  restarts: [ 50000, 100000, 150000 ]
-  restart_weights: [ 1, 1, 1 ]
-  eta_min: !!float 1e-7
-
-  pixel_criterion: l1
-  pixel_weight: 1.0
-
-  manual_seed: 10
-  val_freq: !!float 5e3
-
-#### logger
-logger:
-  print_freq: 100
-  save_checkpoint_freq: !!float 1e3

models/SRFlow/code/confs/RRDB_DF2K_8X.yml

@@ -1,85 +0,0 @@
-# Copyright (c) 2020 Huawei Technologies Co., Ltd.
-# Licensed under CC BY-NC-SA 4.0 (Attribution-NonCommercial-ShareAlike 4.0 International) (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode
-#
-# The code is released for academic research use only. For commercial use, please contact Huawei Technologies Co., Ltd.
-# 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.
-#
-# This file contains content licensed by https://github.com/xinntao/BasicSR/blob/master/LICENSE/LICENSE
-
-#### general settings
-name: train
-use_tb_logger: true
-model: SR
-distortion: sr
-scale: 8
-gpu_ids: [ 0 ]
-
-#### datasets
-datasets:
-  train:
-    name: CelebA_160_tr
-    mode: LRHR_PKL
-    dataroot_GT: ../datasets/DF2K-train-gt_1pct.pklv4
-    dataroot_LQ: ../datasets/DF2K-train-x8_1pct.pklv4
-    quant: 32
-
-    use_shuffle: true
-    n_workers: 3  # per GPU
-    batch_size: 16
-    GT_size: 160
-    use_flip: true
-    color: RGB
-
-  val:
-    name: CelebA_160_va
-    mode: LRHR_PKL
-    dataroot_GT: ../datasets/DF2K-valid-gt_1pct.pklv4
-    dataroot_LQ: ../datasets/DF2K-valid-x8_1pct.pklv4
-    quant: 32
-    n_max: 20
-
-#### network structures
-network_G:
-  which_model_G: RRDBNet
-  in_nc: 3
-  out_nc: 3
-  nf: 64
-  nb: 23
-
-#### path
-path:
-  pretrain_model_G: ~
-  strict_load: true
-  resume_state: auto
-
-#### training settings: learning rate scheme, loss
-train:
-  lr_G: !!float 2e-4
-  lr_scheme: CosineAnnealingLR_Restart
-  beta1: 0.9
-  beta2: 0.99
-  niter: 200000
-  warmup_iter: -1  # no warm up
-  T_period: [ 50000, 50000, 50000, 50000 ]
-  restarts: [ 50000, 100000, 150000 ]
-  restart_weights: [ 1, 1, 1 ]
-  eta_min: !!float 1e-7
-
-  pixel_criterion: l1
-  pixel_weight: 1.0
-
-  manual_seed: 10
-  val_freq: !!float 5e3
-
-#### logger
-logger:
-  print_freq: 100
-  save_checkpoint_freq: !!float 1e3

models/SRFlow/code/confs/SRFlow_CelebA_8X.yml

@@ -1,107 +0,0 @@
-# Copyright (c) 2020 Huawei Technologies Co., Ltd.
-# Licensed under CC BY-NC-SA 4.0 (Attribution-NonCommercial-ShareAlike 4.0 International) (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode
-#
-# The code is released for academic research use only. For commercial use, please contact Huawei Technologies Co., Ltd.
-# 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.
-#
-# This file contains content licensed by https://github.com/xinntao/BasicSR/blob/master/LICENSE/LICENSE
-
-#### general settings
-name: train
-use_tb_logger: true
-model: SRFlow
-distortion: sr
-scale: 8
-gpu_ids: [ 0 ]
-
-#### datasets
-datasets:
-  train:
-    name: CelebA_160_tr
-    mode: LRHR_PKL
-    dataroot_GT: ../datasets/celebA-train-gt.pklv4
-    dataroot_LQ: ../datasets/celebA-train-x8.pklv4
-    quant: 32
-
-    use_shuffle: true
-    n_workers: 3  # per GPU
-    batch_size: 16
-    GT_size: 160
-    use_flip: true
-    color: RGB
-  val:
-    name: CelebA_160_va
-    mode: LRHR_PKL
-    dataroot_GT: ../datasets/celebA-train-gt.pklv4
-    dataroot_LQ: ../datasets/celebA-train-x8.pklv4
-    quant: 32
-    n_max: 20
-
-#### Test Settings
-dataroot_GT: ../datasets/celebA-validation-gt
-dataroot_LR: ../datasets/celebA-validation-x8
-model_path: ../pretrained_models/SRFlow_CelebA_8X.pth
-heat: 0.9 # This is the standard deviation of the latent vectors
-
-#### network structures
-network_G:
-  which_model_G: SRFlowNet
-  in_nc: 3
-  out_nc: 3
-  nf: 64
-  nb: 8
-  upscale: 8
-  train_RRDB: false
-  train_RRDB_delay: 0.5
-
-  flow:
-    K: 16
-    L: 4
-    noInitialInj: true
-    coupling: CondAffineSeparatedAndCond
-    additionalFlowNoAffine: 2
-    split:
-      enable: true
-    fea_up0: true
-    stackRRDB:
-      blocks: [ 1, 3, 5, 7 ]
-      concat: true
-
-#### path
-path:
-  pretrain_model_G: ../pretrained_models/RRDB_CelebA_8X.pth
-  strict_load: true
-  resume_state: auto
-
-#### training settings: learning rate scheme, loss
-train:
-  manual_seed: 10
-  lr_G: !!float 5e-4
-  weight_decay_G: 0
-  beta1: 0.9
-  beta2: 0.99
-  lr_scheme: MultiStepLR
-  warmup_iter: -1  # no warm up
-  lr_steps_rel: [ 0.5, 0.75, 0.9, 0.95 ]
-  lr_gamma: 0.5
-
-  niter: 200000
-  val_freq: 40000
-
-#### validation settings
-val:
-  heats: [ 0.0, 0.5, 0.75, 1.0 ]
-  n_sample: 3
-
-#### logger
-logger:
-  print_freq: 100
-  save_checkpoint_freq: !!float 1e3

models/SRFlow/code/confs/SRFlow_DF2K_8X.yml

@@ -1,112 +0,0 @@
-# Copyright (c) 2020 Huawei Technologies Co., Ltd.
-# Licensed under CC BY-NC-SA 4.0 (Attribution-NonCommercial-ShareAlike 4.0 International) (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode
-#
-# The code is released for academic research use only. For commercial use, please contact Huawei Technologies Co., Ltd.
-# 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.
-#
-# This file contains content licensed by https://github.com/xinntao/BasicSR/blob/master/LICENSE/LICENSE
-
-#### general settings
-name: train
-use_tb_logger: true
-model: SRFlow
-distortion: sr
-scale: 8
-gpu_ids: [ 0 ]
-
-#### datasets
-datasets:
-  train:
-    name: CelebA_160_tr
-    mode: LRHR_PKL
-    dataroot_GT: ../datasets/DF2K-tr.pklv4
-    dataroot_LQ: ../datasets/DF2K-tr_X8.pklv4
-    quant: 32
-
-    use_shuffle: true
-    n_workers: 3  # per GPU
-    batch_size: 16
-    GT_size: 160
-    use_flip: true
-    color: RGB
-
-  val:
-    name: CelebA_160_va
-    mode: LRHR_PKL
-    dataroot_GT: ../datasets/DIV2K-va.pklv4
-    dataroot_LQ: ../datasets/DIV2K-va_X8.pklv4
-    quant: 32
-    n_max: 20
-
-#### Test Settings
-dataroot_GT: ../datasets/div2k-validation-modcrop8-gt
-dataroot_LR: ../datasets/div2k-validation-modcrop8-x8
-model_path: ../pretrained_models/SRFlow_DF2K_8X.pth
-heat: 0.9 # This is the standard deviation of the latent vectors
-
-#### network structures
-network_G:
-  which_model_G: SRFlowNet
-  in_nc: 3
-  out_nc: 3
-  nf: 64
-  nb: 23
-  upscale: 8
-  train_RRDB: false
-  train_RRDB_delay: 0.5
-
-  flow:
-    K: 16
-    L: 4
-    noInitialInj: true
-    coupling: CondAffineSeparatedAndCond
-    additionalFlowNoAffine: 2
-    split:
-      enable: true
-    fea_up0: true
-    stackRRDB:
-      blocks: [ 1, 3, 5, 7 ]
-      concat: true
-
-#### path
-path:
-  pretrain_model_G: ../pretrained_models/RRDB_DF2K_8X.pth
-  strict_load: true
-  resume_state: auto
-
-#### training settings: learning rate scheme, loss
-train:
-  manual_seed: 10
-  lr_G: !!float 5e-4
-  weight_decay_G: 0
-  beta1: 0.9
-  beta2: 0.99
-  lr_scheme: MultiStepLR
-  warmup_iter: -1  # no warm up
-  lr_steps_rel: [ 0.5, 0.75, 0.9, 0.95 ]
-  lr_gamma: 0.5
-
-  niter: 200000
-  val_freq: 40000
-
-#### validation settings
-val:
-  heats: [ 0.0, 0.5, 0.75, 1.0 ]
-  n_sample: 3
-
-test:
-  heats: [ 0.0, 0.7, 0.8, 0.9 ]
-
-#### logger
-logger:
-  # Debug print_freq: 100
-  print_freq: 100
-  save_checkpoint_freq: !!float 1e3

models/SRFlow/code/data/LRHR_PKL_dataset.py

@@ -1,179 +0,0 @@
-# Copyright (c) 2020 Huawei Technologies Co., Ltd.
-# Licensed under CC BY-NC-SA 4.0 (Attribution-NonCommercial-ShareAlike 4.0 International) (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode
-#
-# The code is released for academic research use only. For commercial use, please contact Huawei Technologies Co., Ltd.
-# 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.
-#
-# This file contains content licensed by https://github.com/xinntao/BasicSR/blob/master/LICENSE/LICENSE
-
-import os
-import subprocess
-import torch.utils.data as data
-import numpy as np
-import time
-import torch
-
-import pickle
-
-
-class LRHR_PKLDataset(data.Dataset):
-    def __init__(self, opt):
-        super(LRHR_PKLDataset, self).__init__()
-        self.opt = opt
-        self.crop_size = opt.get("GT_size", None)
-        self.scale = None
-        self.random_scale_list = [1]
-
-        hr_file_path = opt["dataroot_GT"]
-        lr_file_path = opt["dataroot_LQ"]
-        y_labels_file_path = opt['dataroot_y_labels']
-
-        gpu = True
-        augment = True
-
-        self.use_flip = opt["use_flip"] if "use_flip" in opt.keys() else False
-        self.use_rot = opt["use_rot"] if "use_rot" in opt.keys() else False
-        self.use_crop = opt["use_crop"] if "use_crop" in opt.keys() else False
-        self.center_crop_hr_size = opt.get("center_crop_hr_size", None)
-
-        n_max = opt["n_max"] if "n_max" in opt.keys() else int(1e8)
-
-        t = time.time()
-        self.lr_images = self.load_pkls(lr_file_path, n_max)
-        self.hr_images = self.load_pkls(hr_file_path, n_max)
-
-        min_val_hr = np.min([i.min() for i in self.hr_images[:20]])
-        max_val_hr = np.max([i.max() for i in self.hr_images[:20]])
-
-        min_val_lr = np.min([i.min() for i in self.lr_images[:20]])
-        max_val_lr = np.max([i.max() for i in self.lr_images[:20]])
-
-        t = time.time() - t
-        print("Loaded {} HR images with [{:.2f}, {:.2f}] in {:.2f}s from {}".
-              format(len(self.hr_images), min_val_hr, max_val_hr, t, hr_file_path))
-        print("Loaded {} LR images with [{:.2f}, {:.2f}] in {:.2f}s from {}".
-              format(len(self.lr_images), min_val_lr, max_val_lr, t, lr_file_path))
-
-        self.gpu = gpu
-        self.augment = augment
-
-        self.measures = None
-
-    def load_pkls(self, path, n_max):
-        assert os.path.isfile(path), path
-        images = []
-        with open(path, "rb") as f:
-            images += pickle.load(f)
-        assert len(images) > 0, path
-        images = images[:n_max]
-        images = [np.transpose(image, [2, 0, 1]) for image in images]
-        return images
-
-    def __len__(self):
-        return len(self.hr_images)
-
-    def __getitem__(self, item):
-        hr = self.hr_images[item]
-        lr = self.lr_images[item]
-
-        if self.scale == None:
-            self.scale = hr.shape[1] // lr.shape[1]
-            assert hr.shape[1] == self.scale * lr.shape[1], ('non-fractional ratio', lr.shape, hr.shape)
-
-        if self.use_crop:
-            hr, lr = random_crop(hr, lr, self.crop_size, self.scale, self.use_crop)
-
-        if self.center_crop_hr_size:
-            hr, lr = center_crop(hr, self.center_crop_hr_size), center_crop(lr, self.center_crop_hr_size // self.scale)
-
-        if self.use_flip:
-            hr, lr = random_flip(hr, lr)
-
-        if self.use_rot:
-            hr, lr = random_rotation(hr, lr)
-
-        hr = hr / 255.0
-        lr = lr / 255.0
-
-        if self.measures is None or np.random.random() < 0.05:
-            if self.measures is None:
-                self.measures = {}
-            self.measures['hr_means'] = np.mean(hr)
-            self.measures['hr_stds'] = np.std(hr)
-            self.measures['lr_means'] = np.mean(lr)
-            self.measures['lr_stds'] = np.std(lr)
-
-        hr = torch.Tensor(hr)
-        lr = torch.Tensor(lr)
-
-        # if self.gpu:
-        #    hr = hr.cuda()
-        #    lr = lr.cuda()
-
-        return {'LQ': lr, 'GT': hr, 'LQ_path': str(item), 'GT_path': str(item)}
-
-    def print_and_reset(self, tag):
-        m = self.measures
-        kvs = []
-        for k in sorted(m.keys()):
-            kvs.append("{}={:.2f}".format(k, m[k]))
-        print("[KPI] " + tag + ": " + ", ".join(kvs))
-        self.measures = None
-
-
-def random_flip(img, seg):
-    random_choice = np.random.choice([True, False])
-    img = img if random_choice else np.flip(img, 2).copy()
-    seg = seg if random_choice else np.flip(seg, 2).copy()
-    return img, seg
-
-
-def random_rotation(img, seg):
-    random_choice = np.random.choice([0, 1, 3])
-    img = np.rot90(img, random_choice, axes=(1, 2)).copy()
-    seg = np.rot90(seg, random_choice, axes=(1, 2)).copy()
-    return img, seg
-
-
-def random_crop(hr, lr, size_hr, scale, random):
-    size_lr = size_hr // scale
-
-    size_lr_x = lr.shape[1]
-    size_lr_y = lr.shape[2]
-
-    start_x_lr = np.random.randint(low=0, high=(size_lr_x - size_lr) + 1) if size_lr_x > size_lr else 0
-    start_y_lr = np.random.randint(low=0, high=(size_lr_y - size_lr) + 1) if size_lr_y > size_lr else 0
-
-    # LR Patch
-    lr_patch = lr[:, start_x_lr:start_x_lr + size_lr, start_y_lr:start_y_lr + size_lr]
-
-    # HR Patch
-    start_x_hr = start_x_lr * scale
-    start_y_hr = start_y_lr * scale
-    hr_patch = hr[:, start_x_hr:start_x_hr + size_hr, start_y_hr:start_y_hr + size_hr]
-
-    return hr_patch, lr_patch
-
-
-def center_crop(img, size):
-    assert img.shape[1] == img.shape[2], img.shape
-    border_double = img.shape[1] - size
-    assert border_double % 2 == 0, (img.shape, size)
-    border = border_double // 2
-    return img[:, border:-border, border:-border]
-
-
-def center_crop_tensor(img, size):
-    assert img.shape[2] == img.shape[3], img.shape
-    border_double = img.shape[2] - size
-    assert border_double % 2 == 0, (img.shape, size)
-    border = border_double // 2
-    return img[:, :, border:-border, border:-border]

models/SRFlow/code/data/__init__.py

@@ -1,51 +0,0 @@
-# Copyright (c) 2020 Huawei Technologies Co., Ltd.
-# Licensed under CC BY-NC-SA 4.0 (Attribution-NonCommercial-ShareAlike 4.0 International) (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode
-#
-# The code is released for academic research use only. For commercial use, please contact Huawei Technologies Co., Ltd.
-# 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.
-#
-# This file contains content licensed by https://github.com/xinntao/BasicSR/blob/master/LICENSE/LICENSE
-
-'''create dataset and dataloader'''
-import logging
-import torch
-import torch.utils.data
-
-
-def create_dataloader(dataset, dataset_opt, opt=None, sampler=None):
-    phase = dataset_opt.get('phase', 'test')
-    if phase == 'train':
-        gpu_ids = opt.get('gpu_ids', None)
-        gpu_ids = gpu_ids if gpu_ids else []
-        num_workers = dataset_opt['n_workers'] * len(gpu_ids)
-        batch_size = dataset_opt['batch_size']
-        shuffle = True
-        return torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=shuffle,
-                                           num_workers=num_workers, sampler=sampler, drop_last=True,
-                                           pin_memory=False)
-    else:
-        return torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False, num_workers=1,
-                                           pin_memory=True)
-
-
-def create_dataset(dataset_opt):
-    print(dataset_opt)
-    mode = dataset_opt['mode']
-    if mode == 'LRHR_PKL':
-        from data.LRHR_PKL_dataset import LRHR_PKLDataset as D
-    else:
-        raise NotImplementedError('Dataset [{:s}] is not recognized.'.format(mode))
-    dataset = D(dataset_opt)
-
-    logger = logging.getLogger('base')
-    logger.info('Dataset [{:s} - {:s}] is created.'.format(dataset.__class__.__name__,
-                                                           dataset_opt['name']))
-    return dataset

models/SRFlow/code/imresize.py

@@ -1,180 +0,0 @@
-        # https://github.com/fatheral/matlab_imresize
-#
-# MIT License
-#
-# Copyright (c) 2020 Alex
-#
-# 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.
-
-
-from __future__ import print_function
-import numpy as np
-from math import ceil, floor
-
-
-def deriveSizeFromScale(img_shape, scale):
-    output_shape = []
-    for k in range(2):
-        output_shape.append(int(ceil(scale[k] * img_shape[k])))
-    return output_shape
-
-
-def deriveScaleFromSize(img_shape_in, img_shape_out):
-    scale = []
-    for k in range(2):
-        scale.append(1.0 * img_shape_out[k] / img_shape_in[k])
-    return scale
-
-
-def triangle(x):
-    x = np.array(x).astype(np.float64)
-    lessthanzero = np.logical_and((x >= -1), x < 0)
-    greaterthanzero = np.logical_and((x <= 1), x >= 0)
-    f = np.multiply((x + 1), lessthanzero) + np.multiply((1 - x), greaterthanzero)
-    return f
-
-
-def cubic(x):
-    x = np.array(x).astype(np.float64)
-    absx = np.absolute(x)
-    absx2 = np.multiply(absx, absx)
-    absx3 = np.multiply(absx2, absx)
-    f = np.multiply(1.5 * absx3 - 2.5 * absx2 + 1, absx <= 1) + np.multiply(-0.5 * absx3 + 2.5 * absx2 - 4 * absx + 2,
-                                                                            (1 < absx) & (absx <= 2))
-    return f
-
-
-def contributions(in_length, out_length, scale, kernel, k_width):
-    if scale < 1:
-        h = lambda x: scale * kernel(scale * x)
-        kernel_width = 1.0 * k_width / scale
-    else:
-        h = kernel
-        kernel_width = k_width
-    x = np.arange(1, out_length + 1).astype(np.float64)
-    u = x / scale + 0.5 * (1 - 1 / scale)
-    left = np.floor(u - kernel_width / 2)
-    P = int(ceil(kernel_width)) + 2
-    ind = np.expand_dims(left, axis=1) + np.arange(P) - 1  # -1 because indexing from 0
-    indices = ind.astype(np.int32)
-    weights = h(np.expand_dims(u, axis=1) - indices - 1)  # -1 because indexing from 0
-    weights = np.divide(weights, np.expand_dims(np.sum(weights, axis=1), axis=1))
-    aux = np.concatenate((np.arange(in_length), np.arange(in_length - 1, -1, step=-1))).astype(np.int32)
-    indices = aux[np.mod(indices, aux.size)]
-    ind2store = np.nonzero(np.any(weights, axis=0))
-    weights = weights[:, ind2store]
-    indices = indices[:, ind2store]
-    return weights, indices
-
-
-def imresizemex(inimg, weights, indices, dim):
-    in_shape = inimg.shape
-    w_shape = weights.shape
-    out_shape = list(in_shape)
-    out_shape[dim] = w_shape[0]
-    outimg = np.zeros(out_shape)
-    if dim == 0:
-        for i_img in range(in_shape[1]):
-            for i_w in range(w_shape[0]):
-                w = weights[i_w, :]
-                ind = indices[i_w, :]
-                im_slice = inimg[ind, i_img].astype(np.float64)
-                outimg[i_w, i_img] = np.sum(np.multiply(np.squeeze(im_slice, axis=0), w.T), axis=0)
-    elif dim == 1:
-        for i_img in range(in_shape[0]):
-            for i_w in range(w_shape[0]):
-                w = weights[i_w, :]
-                ind = indices[i_w, :]
-                im_slice = inimg[i_img, ind].astype(np.float64)
-                outimg[i_img, i_w] = np.sum(np.multiply(np.squeeze(im_slice, axis=0), w.T), axis=0)
-    if inimg.dtype == np.uint8:
-        outimg = np.clip(outimg, 0, 255)
-        return np.around(outimg).astype(np.uint8)
-    else:
-        return outimg
-
-
-def imresizevec(inimg, weights, indices, dim):
-    wshape = weights.shape
-    if dim == 0:
-        weights = weights.reshape((wshape[0], wshape[2], 1, 1))
-        outimg = np.sum(weights * ((inimg[indices].squeeze(axis=1)).astype(np.float64)), axis=1)
-    elif dim == 1:
-        weights = weights.reshape((1, wshape[0], wshape[2], 1))
-        outimg = np.sum(weights * ((inimg[:, indices].squeeze(axis=2)).astype(np.float64)), axis=2)
-    if inimg.dtype == np.uint8:
-        outimg = np.clip(outimg, 0, 255)
-        return np.around(outimg).astype(np.uint8)
-    else:
-        return outimg
-
-
-def resizeAlongDim(A, dim, weights, indices, mode="vec"):
-    if mode == "org":
-        out = imresizemex(A, weights, indices, dim)
-    else:
-        out = imresizevec(A, weights, indices, dim)
-    return out
-
-
-def imresize(I, scalar_scale=None, method='bicubic', output_shape=None, mode="vec"):
-    if method is 'bicubic':
-        kernel = cubic
-    elif method is 'bilinear':
-        kernel = triangle
-    else:
-        print('Error: Unidentified method supplied')
-
-    kernel_width = 4.0
-    # Fill scale and output_size
-    if scalar_scale is not None:
-        scalar_scale = float(scalar_scale)
-        scale = [scalar_scale, scalar_scale]
-        output_size = deriveSizeFromScale(I.shape, scale)
-    elif output_shape is not None:
-        scale = deriveScaleFromSize(I.shape, output_shape)
-        output_size = list(output_shape)
-    else:
-        print('Error: scalar_scale OR output_shape should be defined!')
-        return
-    scale_np = np.array(scale)
-    order = np.argsort(scale_np)
-    weights = []
-    indices = []
-    for k in range(2):
-        w, ind = contributions(I.shape[k], output_size[k], scale[k], kernel, kernel_width)
-        weights.append(w)
-        indices.append(ind)
-    B = np.copy(I)
-    flag2D = False
-    if B.ndim == 2:
-        B = np.expand_dims(B, axis=2)
-        flag2D = True
-    for k in range(2):
-        dim = order[k]
-        B = resizeAlongDim(B, dim, weights[dim], indices[dim], mode)
-    if flag2D:
-        B = np.squeeze(B, axis=2)
-    return B
-
-
-def convertDouble2Byte(I):
-    B = np.clip(I, 0.0, 1.0)
-    B = 255 * B
-    return np.around(B).astype(np.uint8)

models/SRFlow/code/prepare_data.py

@@ -1,118 +0,0 @@
-# Copyright (c) 2020 Huawei Technologies Co., Ltd.
-# Licensed under CC BY-NC-SA 4.0 (Attribution-NonCommercial-ShareAlike 4.0 International) (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode
-#
-# The code is released for academic research use only. For commercial use, please contact Huawei Technologies Co., Ltd.
-# 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.
-
-import glob
-import os
-import sys
-
-import numpy as np
-import random
-import imageio
-import pickle
-
-from natsort import natsort
-from tqdm import tqdm
-
-def get_img_paths(dir_path, wildcard='*.png'):
-    return natsort.natsorted(glob.glob(dir_path + '/' + wildcard))
-
-def create_all_dirs(path):
-    if "." in path.split("/")[-1]:
-        dirs = os.path.dirname(path)
-    else:
-        dirs = path
-    os.makedirs(dirs, exist_ok=True)
-
-def to_pklv4(obj, path, vebose=False):
-    create_all_dirs(path)
-    with open(path, 'wb') as f:
-        pickle.dump(obj, f, protocol=4)
-    if vebose:
-        print("Wrote {}".format(path))
-
-
-from imresize import imresize
-
-def random_crop(img, size):
-    h, w, c = img.shape
-
-    h_start = np.random.randint(0, h - size)
-    h_end = h_start + size
-
-    w_start = np.random.randint(0, w - size)
-    w_end = w_start + size
-
-    return img[h_start:h_end, w_start:w_end]
-
-
-def imread(img_path):
-    img = imageio.imread(img_path)
-    if len(img.shape) == 2:
-        img = np.stack([img, ] * 3, axis=2)
-    return img
-
-
-def to_pklv4_1pct(obj, path, vebose):
-    n = int(round(len(obj) * 0.01))
-    path = path.replace(".", "_1pct.")
-    to_pklv4(obj[:n], path, vebose=True)
-
-
-def main(dir_path):
-    hrs = []
-    lqs = []
-
-    img_paths = get_img_paths(dir_path)
-    for img_path in tqdm(img_paths):
-        img = imread(img_path)
-
-        for i in range(47):
-            crop = random_crop(img, 256)
-            cropX4 = imresize(crop, scalar_scale=0.25)
-            hrs.append(crop)
-            lqs.append(cropX4)
-
-    shuffle_combined(hrs, lqs)
-
-    hrs_path = get_hrs_path(dir_path)
-    to_pklv4(hrs, hrs_path, vebose=True)
-
-    lqs_path = get_lqs_path(dir_path)
-    to_pklv4(lqs, lqs_path, vebose=True)
-
-
-def get_hrs_path(dir_path):
-    base_dir = '/kaggle/working/'
-    name = os.path.basename(dir_path)
-    hrs_path = os.path.join(base_dir, 'pkls', name + '.pklv4')
-    return hrs_path
-
-
-def get_lqs_path(dir_path):
-    base_dir = '/kaggle/working/'
-    name = os.path.basename(dir_path)
-    hrs_path = os.path.join(base_dir, 'pkls', name + '_X4.pklv4')
-    return hrs_path
-
-
-def shuffle_combined(hrs, lqs):
-    combined = list(zip(hrs, lqs))
-    random.shuffle(combined)
-    hrs[:], lqs[:] = zip(*combined)
-
-
-if __name__ == "__main__":
-    dir_path = sys.argv[1]
-    assert os.path.isdir(dir_path)
-    main(dir_path)

models/SRFlow/code/test.py

@@ -1,192 +0,0 @@
-# Copyright (c) 2020 Huawei Technologies Co., Ltd.
-# Licensed under CC BY-NC-SA 4.0 (Attribution-NonCommercial-ShareAlike 4.0 International) (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode
-#
-# The code is released for academic research use only. For commercial use, please contact Huawei Technologies Co., Ltd.
-# 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.
-#
-# This file contains content licensed by https://github.com/xinntao/BasicSR/blob/master/LICENSE/LICENSE
-
-
-import glob 
-import sys
-from collections import OrderedDict
-
-from natsort import natsort
-
-import options.options as option
-from Measure import Measure, psnr
-from imresize import imresize
-from models import create_model
-import torch
-from utils.util import opt_get
-import numpy as np
-import pandas as pd
-import os
-import cv2
-
-
-def fiFindByWildcard(wildcard):
-    return natsort.natsorted(glob.glob(wildcard, recursive=True))
-
-
-def load_model(conf_path):
-    opt = option.parse(conf_path, is_train=False)
-    opt['gpu_ids'] = None
-    opt = option.dict_to_nonedict(opt)
-    model = create_model(opt)
-
-    model_path = opt_get(opt, ['model_path'], None)
-    model.load_network(load_path=model_path, network=model.netG)
-    return model, opt
-
-
-def predict(model, lr):
-    model.feed_data({"LQ": t(lr)}, need_GT=False)
-    model.test()
-    visuals = model.get_current_visuals(need_GT=False)
-    return visuals.get('rlt', visuals.get("SR"))
-
-
-def t(array): return torch.Tensor(np.expand_dims(array.transpose([2, 0, 1]), axis=0).astype(np.float32)) / 255
-
-
-def rgb(t): return (
-        np.clip((t[0] if len(t.shape) == 4 else t).detach().cpu().numpy().transpose([1, 2, 0]), 0, 1) * 255).astype(
-    np.uint8)
-
-
-def imread(path):
-    return cv2.imread(path)[:, :, [2, 1, 0]]
-
-
-def imwrite(path, img):
-    os.makedirs(os.path.dirname(path), exist_ok=True)
-    cv2.imwrite(path, img[:, :, [2, 1, 0]])
-
-
-def imCropCenter(img, size):
-    h, w, c = img.shape
-
-    h_start = max(h // 2 - size // 2, 0)
-    h_end = min(h_start + size, h)
-
-    w_start = max(w // 2 - size // 2, 0)
-    w_end = min(w_start + size, w)
-
-    return img[h_start:h_end, w_start:w_end]
-
-
-def impad(img, top=0, bottom=0, left=0, right=0, color=255):
-    return np.pad(img, [(top, bottom), (left, right), (0, 0)], 'reflect')
-
-
-def main():
-    conf_path = sys.argv[1]
-    conf = conf_path.split('/')[-1].replace('.yml', '')
-    model, opt = load_model(conf_path)
-
-    data_dir = opt['dataroot']
-
-    # this_dir = os.path.dirname(os.path.realpath(__file__))
-    test_dir = os.path.join('/kaggle/working/', 'results', conf)
-    print(f"Out dir: {test_dir}")
-
-    measure = Measure(use_gpu=False)
-
-    fname = f'measure_full.csv'
-    fname_tmp = fname + "_"
-    path_out_measures = os.path.join(test_dir, fname_tmp)
-    path_out_measures_final = os.path.join(test_dir, fname)
-
-    if os.path.isfile(path_out_measures_final):
-        df = pd.read_csv(path_out_measures_final)
-    elif os.path.isfile(path_out_measures):
-        df = pd.read_csv(path_out_measures)
-    else:
-        df = None
-
-    scale = opt['scale']
-
-    pad_factor = 2
-
-    data_sets = [
-        'Set5',
-        'Set14',
-        'Urban100',
-        'BSD100'
-        ]
-    
-    final_df = pd.DataFrame()
-
-    for data_set in data_sets:
-        lr_paths = fiFindByWildcard(os.path.join(data_dir, data_set, '*LR.png'))
-        hr_paths = fiFindByWildcard(os.path.join(data_dir, data_set, '*HR.png'))
-        
-        df = pd.DataFrame(columns=['conf', 'heat', 'data_set', 'name', 'PSNR', 'SSIM', 'LPIPS', 'LRC PSNR'])
-
-        for lr_path, hr_path, idx_test in zip(lr_paths, hr_paths, range(len(lr_paths))):
-            with torch.no_grad(), torch.cuda.amp.autocast():
-                lr = imread(lr_path)
-                hr = imread(hr_path)
-
-                # Pad image to be % 2
-                h, w, c = lr.shape
-                lq_orig = lr.copy()
-                lr = impad(lr, bottom=int(np.ceil(h / pad_factor) * pad_factor - h),
-                        right=int(np.ceil(w / pad_factor) * pad_factor - w))
-
-                lr_t = t(lr)
-
-                heat = opt['heat']
-
-                if df is not None and len(df[(df['heat'] == heat) & (df['name'] == idx_test)]) == 1:
-                    continue
-
-                sr_t = model.get_sr(lq=lr_t, heat=heat)
-
-                sr = rgb(torch.clamp(sr_t, 0, 1))
-                sr = sr[:h * scale, :w * scale]
-
-                path_out_sr = os.path.join(test_dir, data_set, "{:0.2f}".format(heat).replace('.', ''), "{:06d}.png".format(idx_test))
-                imwrite(path_out_sr, sr)
-
-                meas = OrderedDict(conf=conf, heat=heat, data_set=data_set, name=idx_test)
-                meas['PSNR'], meas['SSIM'], meas['LPIPS'] = measure.measure(sr, hr)
-
-                lr_reconstruct_rgb = imresize(sr, 1 / opt['scale'])
-                meas['LRC PSNR'] = psnr(lq_orig, lr_reconstruct_rgb)
-
-                str_out = format_measurements(meas)
-                print(str_out)
-
-                df = df._append(pd.DataFrame([meas]), ignore_index=True)
-            
-        final_df = pd.concat([final_df, df])
-
-    final_df.to_csv(path_out_measures, index=False)
-    os.rename(path_out_measures, path_out_measures_final)
-
-    # str_out = format_measurements(df.mean())
-    # print(f"Results in: {path_out_measures_final}")
-    # print('Mean: ' + str_out)
-
-
-def format_measurements(meas):
-    s_out = []
-    for k, v in meas.items():
-        v = f"{v:0.2f}" if isinstance(v, float) else v
-        s_out.append(f"{k}: {v}")
-    str_out = ", ".join(s_out)
-    return str_out
-
-
-if __name__ == "__main__":
-    main()

models/SRFlow/code/train.py

@@ -1,328 +0,0 @@
-# Copyright (c) 2020 Huawei Technologies Co., Ltd.
-# Licensed under CC BY-NC-SA 4.0 (Attribution-NonCommercial-ShareAlike 4.0 International) (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode
-#
-# The code is released for academic research use only. For commercial use, please contact Huawei Technologies Co., Ltd.
-# 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.
-#
-# This file contains content licensed by https://github.com/xinntao/BasicSR/blob/master/LICENSE/LICENSE
-
-import os
-from os.path import basename
-import math
-import argparse
-import random
-import logging
-import cv2
-
-import torch
-import torch.distributed as dist
-import torch.multiprocessing as mp
-
-import options.options as option
-from utils import util
-from data import create_dataloader, create_dataset
-from models import create_model
-from utils.timer import Timer, TickTock
-from utils.util import get_resume_paths
-
-import wandb
-
-def getEnv(name): import os; return True if name in os.environ.keys() else False
-
-
-def init_dist(backend='nccl', **kwargs):
-    ''' initialization for distributed training'''
-    # if mp.get_start_method(allow_none=True) is None:
-    if mp.get_start_method(allow_none=True) != 'spawn':
-        mp.set_start_method('spawn')
-    rank = int(os.environ['RANK'])
-    num_gpus = torch.cuda.device_count()
-    torch.cuda.set_deviceDistIterSampler(rank % num_gpus)
-    dist.init_process_group(backend=backend, **kwargs)
-
-
-def main():
-    wandb.init(project='srflow')
-    #### options
-    parser = argparse.ArgumentParser()
-    parser.add_argument('-opt', type=str, help='Path to option YMAL file.')
-    parser.add_argument('--launcher', choices=['none', 'pytorch'], default='none',
-                        help='job launcher')
-    parser.add_argument('--local_rank', type=int, default=0)
-    args = parser.parse_args()
-    opt = option.parse(args.opt, is_train=True)
-
-    #### distributed training settings
-    opt['dist'] = False
-    rank = -1
-    print('Disabled distributed training.')
-
-    #### loading resume state if exists
-    if opt['path'].get('resume_state', None):
-        resume_state_path, _ = get_resume_paths(opt)
-
-        # distributed resuming: all load into default GPU
-        if resume_state_path is None:
-            resume_state = None
-        else:
-            device_id = torch.cuda.current_device()
-            resume_state = torch.load(resume_state_path,
-                                      map_location=lambda storage, loc: storage.cuda(device_id))
-            option.check_resume(opt, resume_state['iter'])  # check resume options
-    else:
-        resume_state = None
-
-    #### mkdir and loggers
-    if rank <= 0:  # normal training (rank -1) OR distributed training (rank 0)
-        if resume_state is None:
-            util.mkdir_and_rename(
-                opt['path']['experiments_root'])  # rename experiment folder if exists
-            util.mkdirs((path for key, path in opt['path'].items() if not key == 'experiments_root'
-                         and 'pretrain_model' not in key and 'resume' not in key))
-
-        # config loggers. Before it, the log will not work
-        util.setup_logger('base', opt['path']['log'], 'train_' + opt['name'], level=logging.INFO,
-                          screen=True, tofile=True)
-        util.setup_logger('val', opt['path']['log'], 'val_' + opt['name'], level=logging.INFO,
-                          screen=True, tofile=True)
-        logger = logging.getLogger('base')
-        logger.info(option.dict2str(opt))
-
-        # tensorboard logger
-        if opt.get('use_tb_logger', False) and 'debug' not in opt['name']:
-            version = float(torch.__version__[0:3])
-            if version >= 1.1:  # PyTorch 1.1
-                from torch.utils.tensorboard import SummaryWriter
-            else:
-                logger.info(
-                    'You are using PyTorch {}. Tensorboard will use [tensorboardX]'.format(version))
-                from tensorboardX import SummaryWriter
-            conf_name = basename(args.opt).replace(".yml", "")
-            exp_dir = opt['path']['experiments_root']
-            log_dir_train = os.path.join(exp_dir, 'tb', conf_name, 'train')
-            log_dir_valid = os.path.join(exp_dir, 'tb', conf_name, 'valid')
-            tb_logger_train = SummaryWriter(log_dir=log_dir_train)
-            tb_logger_valid = SummaryWriter(log_dir=log_dir_valid)
-    else:
-        util.setup_logger('base', opt['path']['log'], 'train', level=logging.INFO, screen=True)
-        logger = logging.getLogger('base')
-
-    # convert to NoneDict, which returns None for missing keys
-    opt = option.dict_to_nonedict(opt)
-
-    #### random seed
-    seed = opt['train']['manual_seed']
-    if seed is None:
-        seed = random.randint(1, 10000)
-    if rank <= 0:
-        logger.info('Random seed: {}'.format(seed))
-    util.set_random_seed(seed)
-
-    torch.backends.cudnn.benchmark = True
-    # torch.backends.cudnn.deterministic = True
-
-    #### create train and val dataloader
-    dataset_ratio = 200  # enlarge the size of each epoch
-    for phase, dataset_opt in opt['datasets'].items():
-        if phase == 'train':
-            full_dataset = create_dataset(dataset_opt)
-            print('Dataset created')
-            train_len = int(len(full_dataset) * 0.95)
-            val_len = len(full_dataset) - train_len
-            train_set, val_set = torch.utils.data.random_split(full_dataset, [train_len, val_len])
-            train_size = int(math.ceil(train_len / dataset_opt['batch_size']))
-            total_iters = int(opt['train']['niter'])
-            total_epochs = int(math.ceil(total_iters / train_size))
-            train_sampler = None
-            train_loader = create_dataloader(train_set, dataset_opt, opt, train_sampler)
-            if rank <= 0:
-                logger.info('Number of train images: {:,d}, iters: {:,d}'.format(
-                    len(train_set), train_size))
-                logger.info('Total epochs needed: {:d} for iters {:,d}'.format(
-                    total_epochs, total_iters))
-            val_loader = torch.utils.data.DataLoader(val_set, batch_size=1, shuffle=False, num_workers=1,
-                                           pin_memory=True)
-        elif phase == 'val':
-            continue
-        else:
-            raise NotImplementedError('Phase [{:s}] is not recognized.'.format(phase))
-    assert train_loader is not None
-
-    #### create model
-    current_step = 0 if resume_state is None else resume_state['iter']
-    model = create_model(opt, current_step)
-
-    #### resume training
-    if resume_state:
-        logger.info('Resuming training from epoch: {}, iter: {}.'.format(
-            resume_state['epoch'], resume_state['iter']))
-
-        start_epoch = resume_state['epoch']
-        current_step = resume_state['iter']
-        model.resume_training(resume_state)  # handle optimizers and schedulers
-    else:
-        current_step = 0
-        start_epoch = 0
-
-    #### training
-    timer = Timer()
-    logger.info('Start training from epoch: {:d}, iter: {:d}'.format(start_epoch, current_step))
-    timerData = TickTock()
-
-    for epoch in range(start_epoch, total_epochs + 1):
-        if opt['dist']:
-            train_sampler.set_epoch(epoch)
-
-        timerData.tick()
-        for _, train_data in enumerate(train_loader):
-            timerData.tock()
-            current_step += 1
-            if current_step > total_iters:
-                break
-
-            #### training
-            model.feed_data(train_data)
-
-            #### update learning rate
-            model.update_learning_rate(current_step, warmup_iter=opt['train']['warmup_iter'])
-
-            try:
-                nll = model.optimize_parameters(current_step)
-            except RuntimeError as e:
-                print("Skipping ERROR caught in nll = model.optimize_parameters(current_step): ")
-                print(e)
-
-            if nll is None:
-                nll = 0
-
-            wandb.log({"loss": nll})
-            #### log
-            def eta(t_iter):
-                return (t_iter * (opt['train']['niter'] - current_step)) / 3600
-
-            if current_step % opt['logger']['print_freq'] == 0 \
-                    or current_step - (resume_state['iter'] if resume_state else 0) < 25:
-                avg_time = timer.get_average_and_reset()
-                avg_data_time = timerData.get_average_and_reset()
-                message = '<epoch:{:3d}, iter:{:8,d}, lr:{:.3e}, t:{:.2e}, td:{:.2e}, eta:{:.2e}, nll:{:.3e}> '.format(
-                    epoch, current_step, model.get_current_learning_rate(), avg_time, avg_data_time,
-                    eta(avg_time), nll)
-                print(message)
-            timer.tick()
-            # Reduce number of logs
-            if current_step % 5 == 0:
-                tb_logger_train.add_scalar('loss/nll', nll, current_step)
-                tb_logger_train.add_scalar('lr/base', model.get_current_learning_rate(), current_step)
-                tb_logger_train.add_scalar('time/iteration', timer.get_last_iteration(), current_step)
-                tb_logger_train.add_scalar('time/data', timerData.get_last_iteration(), current_step)
-                tb_logger_train.add_scalar('time/eta', eta(timer.get_last_iteration()), current_step)
-                for k, v in model.get_current_log().items():
-                    tb_logger_train.add_scalar(k, v, current_step)
-
-            # validation
-            if current_step % opt['train']['val_freq'] == 0 and rank <= 0:
-                avg_psnr = 0.0
-                idx = 0
-                nlls = []
-                for val_data in val_loader:
-                    idx += 1
-                    img_name = os.path.splitext(os.path.basename(val_data['LQ_path'][0]))[0]
-                    img_dir = os.path.join(opt['path']['val_images'], img_name)
-                    util.mkdir(img_dir)
-
-                    model.feed_data(val_data)
-
-                    nll = model.test()
-                    if nll is None:
-                        nll = 0
-                    nlls.append(nll)
-
-                    visuals = model.get_current_visuals()
-
-                    sr_img = None
-                    # Save SR images for reference
-                    if hasattr(model, 'heats'):
-                        for heat in model.heats:
-                            for i in range(model.n_sample):
-                                sr_img = util.tensor2img(visuals['SR', heat, i])  # uint8
-                                save_img_path = os.path.join(img_dir,
-                                                             '{:s}_{:09d}_h{:03d}_s{:d}.png'.format(img_name,
-                                                                                                    current_step,
-                                                                                                    int(heat * 100), i))
-                                util.save_img(sr_img, save_img_path)
-                    else:
-                        sr_img = util.tensor2img(visuals['SR'])  # uint8
-                        save_img_path = os.path.join(img_dir,
-                                                     '{:s}_{:d}.png'.format(img_name, current_step))
-                        util.save_img(sr_img, save_img_path)
-                    assert sr_img is not None
-
-                    # Save LQ images for reference
-                    save_img_path_lq = os.path.join(img_dir,
-                                                    '{:s}_LQ.png'.format(img_name))
-                    if not os.path.isfile(save_img_path_lq):
-                        lq_img = util.tensor2img(visuals['LQ'])  # uint8
-                        util.save_img(
-                            cv2.resize(lq_img, dsize=None, fx=opt['scale'], fy=opt['scale'],
-                                       interpolation=cv2.INTER_NEAREST),
-                            save_img_path_lq)
-
-                    # Save GT images for reference
-                    gt_img = util.tensor2img(visuals['GT'])  # uint8
-                    save_img_path_gt = os.path.join(img_dir,
-                                                    '{:s}_GT.png'.format(img_name))
-                    if not os.path.isfile(save_img_path_gt):
-                        util.save_img(gt_img, save_img_path_gt)
-
-                    # calculate PSNR
-                    crop_size = opt['scale']
-                    gt_img = gt_img / 255.
-                    sr_img = sr_img / 255.
-                    cropped_sr_img = sr_img[crop_size:-crop_size, crop_size:-crop_size, :]
-                    cropped_gt_img = gt_img[crop_size:-crop_size, crop_size:-crop_size, :]
-                    avg_psnr += util.calculate_psnr(cropped_sr_img * 255, cropped_gt_img * 255)
-
-                avg_psnr = avg_psnr / idx
-                avg_nll = sum(nlls) / len(nlls)
-
-                # log
-                logger.info('# Validation # PSNR: {:.4e}'.format(avg_psnr))
-                logger_val = logging.getLogger('val')  # validation logger
-                logger_val.info('<epoch:{:3d}, iter:{:8,d}> psnr: {:.4e}'.format(
-                    epoch, current_step, avg_psnr))
-
-                # tensorboard logger
-                tb_logger_valid.add_scalar('loss/psnr', avg_psnr, current_step)
-                tb_logger_valid.add_scalar('loss/nll', avg_nll, current_step)
-
-                tb_logger_train.flush()
-                tb_logger_valid.flush()
-
-            #### save models and training states
-            if current_step % opt['logger']['save_checkpoint_freq'] == 0:
-                if rank <= 0:
-                    logger.info('Saving models and training states.')
-                    model.save(current_step)
-                    model.save_training_state(epoch, current_step)
-
-            timerData.tick()
-
-    with open(os.path.join(opt['path']['root'], "TRAIN_DONE"), 'w') as f:
-        f.write("TRAIN_DONE")
-
-    if rank <= 0:
-        logger.info('Saving the final model.')
-        model.save('latest')
-        logger.info('End of training.')
-
-
-if __name__ == '__main__':
-    main()