X-Restormer/inference.py

# modified from https://github.com/Andrew0613/X-Restormer/blob/master/xrestormer/test.py

# flake8: noqa
import os.path as osp

import xrestormer.archs
import xrestormer.data
import xrestormer.models
from basicsr.test import test_pipeline

import logging
import torch
from os import path as osp

from basicsr.data import build_dataloader, build_dataset
from basicsr.models import build_model
from basicsr.utils import get_env_info, get_root_logger, get_time_str, make_exp_dirs
from basicsr.utils.options import dict2str, parse_options, ordered_yaml, _postprocess_yml_value
from basicsr.models.sr_model import SRModel


import argparse
import random
import torch
import yaml
from collections import OrderedDict
from os import path as osp

from basicsr.utils import set_random_seed
# from basicsr.utils.dist_util import get_dist_info, init_dist, master_only


config = {
    "xrestormer.denoise_50":{
        "yaml": "/hdd/Restoration/Inference/X-Restormer/options/test/002_xrestormer_denoise.yml"
    },
    "xrestormer.derain":{
        "yaml": "/hdd/Restoration/Inference/X-Restormer/options/test/004_xrestormer_derain.yml"
    },
    "xrestormer.dehaze":{
        "yaml": "/hdd/Restoration/Inference/X-Restormer/options/test/005_xrestormer_dehaze.yml"
    },
    "xrestormer.deblur":{
        "yaml": "/hdd/Restoration/Inference/X-Restormer/options/test/003_xrestormer_deblur.yml"
    },
    "xrestormer.super_resolution":{
        "yaml": "/hdd/Restoration/Inference/X-Restormer/options/test/001_xrestormer_sr.yml"
    }
}

def custom_parse_options(root_path, is_train=True):
    parser = argparse.ArgumentParser()
    parser = argparse.ArgumentParser(description="Single image restoration using Restormer")
    parser.add_argument("--input", required=True, type=str, help="Path to input image")
    parser.add_argument("--output", required=True, type=str, help="Path to save output image")
    parser.add_argument("--model", required=True, choices=['xrestormer.denoise_50', 'xrestormer.derain', 'xrestormer.dehaze', 'xrestormer.deblur', 'xrestormer.super_resolution'],
                        help="Model type to use")
    args = parser.parse_args()
    # parser.add_argument('--opt', type=str, required=True, help='Path to option YAML file.')
    # parser.add_argument('--launcher', choices=['none', 'pytorch', 'slurm'], default='none', help='job launcher')
    # parser.add_argument('--auto_resume', action='store_true')
    # parser.add_argument('--debug', action='store_true')
    # parser.add_argument('--local_rank', type=int, default=0)
    parser.add_argument(
        '--force_yml', nargs='+', default=None, help='Force to update yml files. Examples: train:ema_decay=0.999')
    args = parser.parse_args()
    opt = config[args.model]['yaml']
    # parse yml to dict
    with open(opt, mode='r') as f:
        opt = yaml.load(f, Loader=ordered_yaml()[0])

  
    # init_dist('pytorch')
    # opt['rank'], opt['world_size'] = get_dist_info()

    # random seed
    seed = opt.get('manual_seed')
    if seed is None:
        seed = random.randint(1, 10000)
        opt['manual_seed'] = seed
    # set_random_seed(seed + opt['rank'])

    # force to update yml options
    if args.force_yml is not None:
        for entry in args.force_yml:
            # now do not support creating new keys
            keys, value = entry.split('=')
            keys, value = keys.strip(), value.strip()
            value = _postprocess_yml_value(value)
            eval_str = 'opt'
            for key in keys.split(':'):
                eval_str += f'["{key}"]'
            eval_str += '=value'
            # using exec function
            exec(eval_str)

    opt['auto_resume'] = False
    opt['is_train'] = False

    # debug setting
    # if args.debug and not opt['name'].startswith('debug'):
    #     opt['name'] = 'debug_' + opt['name']

    if opt['num_gpu'] == 'auto':
        opt['num_gpu'] = torch.cuda.device_count()

    # datasets
    for phase, dataset in opt['datasets'].items():
        # for multiple datasets, e.g., val_1, val_2; test_1, test_2
        phase = phase.split('_')[0]
        dataset['phase'] = phase
        if 'scale' in opt:
            dataset['scale'] = opt['scale']
        dataset['dataroot_lq'] = args.input
        # if dataset.get('dataroot_gt') is not None:
        #     dataset['dataroot_gt'] = osp.expanduser(dataset['dataroot_gt'])
        # if dataset.get('dataroot_lq') is not None:
        #     dataset['dataroot_lq'] = osp.expanduser(dataset['dataroot_lq'])

    # paths
    for key, val in opt['path'].items():
        if (val is not None) and ('resume_state' in key or 'pretrain_network' in key):
            opt['path'][key] = osp.expanduser(val)

    # opt['path']['results'] = args.output
    ################### All for this!!!!!!!!!!!!!!! ###################
    # results_root = osp.join(root_path, 'results', opt['name'])
    results_root = args.output #osp.join(opt['path']['results'], opt['name'])
    ################### All for this!!!!!!!!!!!!!!! ###################
    opt['path']['results_root'] = results_root
    opt['path']['log'] = results_root
    opt['path']['visualization'] = osp.join(results_root, 'visualization')

    return opt, args

def custom_test_pipeline(root_path):
    # parse options, set distributed setting, set ramdom seed
    # opt, _ = parse_options(root_path, is_train=False)
    opt, _ = custom_parse_options(root_path, 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
    opt['dist'] = False
    test_loaders = []
    for _, dataset_opt in sorted(opt['datasets'].items()):
        test_set = build_dataset(dataset_opt)
        test_loader = build_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: SRModel = build_model(opt)

    for test_loader in test_loaders:
        test_set_name = test_loader.dataset.opt['name']
        logger.info(f'Testing {test_set_name}...')
        model.validation(test_loader, current_iter=opt['name'], tb_logger=None, save_img=opt['val']['save_img'])

if __name__ == '__main__':
    root_path = osp.abspath(osp.join(__file__, osp.pardir, osp.pardir))
    # test_pipeline(root_path)
    custom_test_pipeline(root_path)