Delete utils

utils/__init__.py

@@ -1,30 +0,0 @@
-from .file_client import FileClient
-from .img_util import crop_border, imfrombytes, img2tensor, imwrite, tensor2img
-from .logger import AvgTimer, MessageLogger, get_env_info, get_root_logger, init_tb_logger, init_wandb_logger
-from .misc import check_resume, get_time_str, make_exp_dirs, mkdir_and_rename, scandir, set_random_seed, sizeof_fmt
-
-__all__ = [
-    # file_client.py
-    'FileClient',
-    # img_util.py
-    'img2tensor',
-    'tensor2img',
-    'imfrombytes',
-    'imwrite',
-    'crop_border',
-    # logger.py
-    'MessageLogger',
-    'AvgTimer',
-    'init_tb_logger',
-    'init_wandb_logger',
-    'get_root_logger',
-    'get_env_info',
-    # misc.py
-    'set_random_seed',
-    'get_time_str',
-    'mkdir_and_rename',
-    'make_exp_dirs',
-    'scandir',
-    'check_resume',
-    'sizeof_fmt',
-]

utils/dist_util.py

@@ -1,82 +0,0 @@
-# Modified from https://github.com/open-mmlab/mmcv/blob/master/mmcv/runner/dist_utils.py  # noqa: E501
-import functools
-import os
-import subprocess
-import torch
-import torch.distributed as dist
-import torch.multiprocessing as mp
-
-
-def init_dist(launcher, backend='nccl', **kwargs):
-    if mp.get_start_method(allow_none=True) is None:
-        mp.set_start_method('spawn')
-    if launcher == 'pytorch':
-        _init_dist_pytorch(backend, **kwargs)
-    elif launcher == 'slurm':
-        _init_dist_slurm(backend, **kwargs)
-    else:
-        raise ValueError(f'Invalid launcher type: {launcher}')
-
-
-def _init_dist_pytorch(backend, **kwargs):
-    rank = int(os.environ['RANK'])
-    num_gpus = torch.cuda.device_count()
-    torch.cuda.set_device(rank % num_gpus)
-    dist.init_process_group(backend=backend, **kwargs)
-
-
-def _init_dist_slurm(backend, port=None):
-    """Initialize slurm distributed training environment.
-
-    If argument ``port`` is not specified, then the master port will be system
-    environment variable ``MASTER_PORT``. If ``MASTER_PORT`` is not in system
-    environment variable, then a default port ``29500`` will be used.
-
-    Args:
-        backend (str): Backend of torch.distributed.
-        port (int, optional): Master port. Defaults to None.
-    """
-    proc_id = int(os.environ['SLURM_PROCID'])
-    ntasks = int(os.environ['SLURM_NTASKS'])
-    node_list = os.environ['SLURM_NODELIST']
-    num_gpus = torch.cuda.device_count()
-    torch.cuda.set_device(proc_id % num_gpus)
-    addr = subprocess.getoutput(f'scontrol show hostname {node_list} | head -n1')
-    # specify master port
-    if port is not None:
-        os.environ['MASTER_PORT'] = str(port)
-    elif 'MASTER_PORT' in os.environ:
-        pass  # use MASTER_PORT in the environment variable
-    else:
-        # 29500 is torch.distributed default port
-        os.environ['MASTER_PORT'] = '29500'
-    os.environ['MASTER_ADDR'] = addr
-    os.environ['WORLD_SIZE'] = str(ntasks)
-    os.environ['LOCAL_RANK'] = str(proc_id % num_gpus)
-    os.environ['RANK'] = str(proc_id)
-    dist.init_process_group(backend=backend)
-
-
-def get_dist_info():
-    if dist.is_available():
-        initialized = dist.is_initialized()
-    else:
-        initialized = False
-    if initialized:
-        rank = dist.get_rank()
-        world_size = dist.get_world_size()
-    else:
-        rank = 0
-        world_size = 1
-    return rank, world_size
-
-
-def master_only(func):
-
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        rank, _ = get_dist_info()
-        if rank == 0:
-            return func(*args, **kwargs)
-
-    return wrapper

utils/file_client.py

@@ -1,167 +0,0 @@
-# Modified from https://github.com/open-mmlab/mmcv/blob/master/mmcv/fileio/file_client.py  # noqa: E501
-from abc import ABCMeta, abstractmethod
-
-
-class BaseStorageBackend(metaclass=ABCMeta):
-    """Abstract class of storage backends.
-
-    All backends need to implement two apis: ``get()`` and ``get_text()``.
-    ``get()`` reads the file as a byte stream and ``get_text()`` reads the file
-    as texts.
-    """
-
-    @abstractmethod
-    def get(self, filepath):
-        pass
-
-    @abstractmethod
-    def get_text(self, filepath):
-        pass
-
-
-class MemcachedBackend(BaseStorageBackend):
-    """Memcached storage backend.
-
-    Attributes:
-        server_list_cfg (str): Config file for memcached server list.
-        client_cfg (str): Config file for memcached client.
-        sys_path (str | None): Additional path to be appended to `sys.path`.
-            Default: None.
-    """
-
-    def __init__(self, server_list_cfg, client_cfg, sys_path=None):
-        if sys_path is not None:
-            import sys
-            sys.path.append(sys_path)
-        try:
-            import mc
-        except ImportError:
-            raise ImportError('Please install memcached to enable MemcachedBackend.')
-
-        self.server_list_cfg = server_list_cfg
-        self.client_cfg = client_cfg
-        self._client = mc.MemcachedClient.GetInstance(self.server_list_cfg, self.client_cfg)
-        # mc.pyvector servers as a point which points to a memory cache
-        self._mc_buffer = mc.pyvector()
-
-    def get(self, filepath):
-        filepath = str(filepath)
-        import mc
-        self._client.Get(filepath, self._mc_buffer)
-        value_buf = mc.ConvertBuffer(self._mc_buffer)
-        return value_buf
-
-    def get_text(self, filepath):
-        raise NotImplementedError
-
-
-class HardDiskBackend(BaseStorageBackend):
-    """Raw hard disks storage backend."""
-
-    def get(self, filepath):
-        filepath = str(filepath)
-        with open(filepath, 'rb') as f:
-            value_buf = f.read()
-        return value_buf
-
-    def get_text(self, filepath):
-        filepath = str(filepath)
-        with open(filepath, 'r') as f:
-            value_buf = f.read()
-        return value_buf
-
-
-class LmdbBackend(BaseStorageBackend):
-    """Lmdb storage backend.
-
-    Args:
-        db_paths (str | list[str]): Lmdb database paths.
-        client_keys (str | list[str]): Lmdb client keys. Default: 'default'.
-        readonly (bool, optional): Lmdb environment parameter. If True,
-            disallow any write operations. Default: True.
-        lock (bool, optional): Lmdb environment parameter. If False, when
-            concurrent access occurs, do not lock the database. Default: False.
-        readahead (bool, optional): Lmdb environment parameter. If False,
-            disable the OS filesystem readahead mechanism, which may improve
-            random read performance when a database is larger than RAM.
-            Default: False.
-
-    Attributes:
-        db_paths (list): Lmdb database path.
-        _client (list): A list of several lmdb envs.
-    """
-
-    def __init__(self, db_paths, client_keys='default', readonly=True, lock=False, readahead=False, **kwargs):
-        try:
-            import lmdb
-        except ImportError:
-            raise ImportError('Please install lmdb to enable LmdbBackend.')
-
-        if isinstance(client_keys, str):
-            client_keys = [client_keys]
-
-        if isinstance(db_paths, list):
-            self.db_paths = [str(v) for v in db_paths]
-        elif isinstance(db_paths, str):
-            self.db_paths = [str(db_paths)]
-        assert len(client_keys) == len(self.db_paths), ('client_keys and db_paths should have the same length, '
-                                                        f'but received {len(client_keys)} and {len(self.db_paths)}.')
-
-        self._client = {}
-        for client, path in zip(client_keys, self.db_paths):
-            self._client[client] = lmdb.open(path, readonly=readonly, lock=lock, readahead=readahead, **kwargs)
-
-    def get(self, filepath, client_key):
-        """Get values according to the filepath from one lmdb named client_key.
-
-        Args:
-            filepath (str | obj:`Path`): Here, filepath is the lmdb key.
-            client_key (str): Used for distinguishing different lmdb envs.
-        """
-        filepath = str(filepath)
-        assert client_key in self._client, (f'client_key {client_key} is not in lmdb clients.')
-        client = self._client[client_key]
-        with client.begin(write=False) as txn:
-            value_buf = txn.get(filepath.encode('ascii'))
-        return value_buf
-
-    def get_text(self, filepath):
-        raise NotImplementedError
-
-
-class FileClient(object):
-    """A general file client to access files in different backend.
-
-    The client loads a file or text in a specified backend from its path
-    and return it as a binary file. it can also register other backend
-    accessor with a given name and backend class.
-
-    Attributes:
-        backend (str): The storage backend type. Options are "disk",
-            "memcached" and "lmdb".
-        client (:obj:`BaseStorageBackend`): The backend object.
-    """
-
-    _backends = {
-        'disk': HardDiskBackend,
-        'memcached': MemcachedBackend,
-        'lmdb': LmdbBackend,
-    }
-
-    def __init__(self, backend='disk', **kwargs):
-        if backend not in self._backends:
-            raise ValueError(f'Backend {backend} is not supported. Currently supported ones'
-                             f' are {list(self._backends.keys())}')
-        self.backend = backend
-        self.client = self._backends[backend](**kwargs)
-
-    def get(self, filepath, client_key='default'):
-        # client_key is used only for lmdb, where different fileclients have
-        # different lmdb environments.
-        if self.backend == 'lmdb':
-            return self.client.get(filepath, client_key)
-        else:
-            return self.client.get(filepath)
-
-    def get_text(self, filepath):
-        return self.client.get_text(filepath)

utils/img_util.py

@@ -1,172 +0,0 @@
-import cv2
-import math
-import numpy as np
-import os
-import torch
-from torchvision.utils import make_grid
-
-
-def img2tensor(imgs, bgr2rgb=True, float32=True):
-    """Numpy array to tensor.
-
-    Args:
-        imgs (list[ndarray] | ndarray): Input images.
-        bgr2rgb (bool): Whether to change bgr to rgb.
-        float32 (bool): Whether to change to float32.
-
-    Returns:
-        list[tensor] | tensor: Tensor images. If returned results only have
-            one element, just return tensor.
-    """
-
-    def _totensor(img, bgr2rgb, float32):
-        if img.shape[2] == 3 and bgr2rgb:
-            if img.dtype == 'float64':
-                img = img.astype('float32')
-            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-        img = torch.from_numpy(img.transpose(2, 0, 1))
-        if float32:
-            img = img.float()
-        return img
-
-    if isinstance(imgs, list):
-        return [_totensor(img, bgr2rgb, float32) for img in imgs]
-    else:
-        return _totensor(imgs, bgr2rgb, float32)
-
-
-def tensor2img(tensor, rgb2bgr=True, out_type=np.uint8, min_max=(0, 1)):
-    """Convert torch Tensors into image numpy arrays.
-
-    After clamping to [min, max], values will be normalized to [0, 1].
-
-    Args:
-        tensor (Tensor or list[Tensor]): Accept shapes:
-            1) 4D mini-batch Tensor of shape (B x 3/1 x H x W);
-            2) 3D Tensor of shape (3/1 x H x W);
-            3) 2D Tensor of shape (H x W).
-            Tensor channel should be in RGB order.
-        rgb2bgr (bool): Whether to change rgb to bgr.
-        out_type (numpy type): output types. If ``np.uint8``, transform outputs
-            to uint8 type with range [0, 255]; otherwise, float type with
-            range [0, 1]. Default: ``np.uint8``.
-        min_max (tuple[int]): min and max values for clamp.
-
-    Returns:
-        (Tensor or list): 3D ndarray of shape (H x W x C) OR 2D ndarray of
-        shape (H x W). The channel order is BGR.
-    """
-    if not (torch.is_tensor(tensor) or (isinstance(tensor, list) and all(torch.is_tensor(t) for t in tensor))):
-        raise TypeError(f'tensor or list of tensors expected, got {type(tensor)}')
-
-    if torch.is_tensor(tensor):
-        tensor = [tensor]
-    result = []
-    for _tensor in tensor:
-        _tensor = _tensor.squeeze(0).float().detach().cpu().clamp_(*min_max)
-        _tensor = (_tensor - min_max[0]) / (min_max[1] - min_max[0])
-
-        n_dim = _tensor.dim()
-        if n_dim == 4:
-            img_np = make_grid(_tensor, nrow=int(math.sqrt(_tensor.size(0))), normalize=False).numpy()
-            img_np = img_np.transpose(1, 2, 0)
-            if rgb2bgr:
-                img_np = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
-        elif n_dim == 3:
-            img_np = _tensor.numpy()
-            img_np = img_np.transpose(1, 2, 0)
-            if img_np.shape[2] == 1:  # gray image
-                img_np = np.squeeze(img_np, axis=2)
-            else:
-                if rgb2bgr:
-                    img_np = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
-        elif n_dim == 2:
-            img_np = _tensor.numpy()
-        else:
-            raise TypeError(f'Only support 4D, 3D or 2D tensor. But received with dimension: {n_dim}')
-        if out_type == np.uint8:
-            # Unlike MATLAB, numpy.unit8() WILL NOT round by default.
-            img_np = (img_np * 255.0).round()
-        img_np = img_np.astype(out_type)
-        result.append(img_np)
-    if len(result) == 1:
-        result = result[0]
-    return result
-
-
-def tensor2img_fast(tensor, rgb2bgr=True, min_max=(0, 1)):
-    """This implementation is slightly faster than tensor2img.
-    It now only supports torch tensor with shape (1, c, h, w).
-
-    Args:
-        tensor (Tensor): Now only support torch tensor with (1, c, h, w).
-        rgb2bgr (bool): Whether to change rgb to bgr. Default: True.
-        min_max (tuple[int]): min and max values for clamp.
-    """
-    output = tensor.squeeze(0).detach().clamp_(*min_max).permute(1, 2, 0)
-    output = (output - min_max[0]) / (min_max[1] - min_max[0]) * 255
-    output = output.type(torch.uint8).cpu().numpy()
-    if rgb2bgr:
-        output = cv2.cvtColor(output, cv2.COLOR_RGB2BGR)
-    return output
-
-
-def imfrombytes(content, flag='color', float32=False):
-    """Read an image from bytes.
-
-    Args:
-        content (bytes): Image bytes got from files or other streams.
-        flag (str): Flags specifying the color type of a loaded image,
-            candidates are `color`, `grayscale` and `unchanged`.
-        float32 (bool): Whether to change to float32., If True, will also norm
-            to [0, 1]. Default: False.
-
-    Returns:
-        ndarray: Loaded image array.
-    """
-    img_np = np.frombuffer(content, np.uint8)
-    imread_flags = {'color': cv2.IMREAD_COLOR, 'grayscale': cv2.IMREAD_GRAYSCALE, 'unchanged': cv2.IMREAD_UNCHANGED}
-    img = cv2.imdecode(img_np, imread_flags[flag])
-    if float32:
-        img = img.astype(np.float32) / 255.
-    return img
-
-
-def imwrite(img, file_path, params=None, auto_mkdir=True):
-    """Write image to file.
-
-    Args:
-        img (ndarray): Image array to be written.
-        file_path (str): Image file path.
-        params (None or list): Same as opencv's :func:`imwrite` interface.
-        auto_mkdir (bool): If the parent folder of `file_path` does not exist,
-            whether to create it automatically.
-
-    Returns:
-        bool: Successful or not.
-    """
-    if auto_mkdir:
-        dir_name = os.path.abspath(os.path.dirname(file_path))
-        os.makedirs(dir_name, exist_ok=True)
-    ok = cv2.imwrite(file_path, img, params)
-    if not ok:
-        raise IOError('Failed in writing images.')
-
-
-def crop_border(imgs, crop_border):
-    """Crop borders of images.
-
-    Args:
-        imgs (list[ndarray] | ndarray): Images with shape (h, w, c).
-        crop_border (int): Crop border for each end of height and weight.
-
-    Returns:
-        list[ndarray]: Cropped images.
-    """
-    if crop_border == 0:
-        return imgs
-    else:
-        if isinstance(imgs, list):
-            return [v[crop_border:-crop_border, crop_border:-crop_border, ...] for v in imgs]
-        else:
-            return imgs[crop_border:-crop_border, crop_border:-crop_border, ...]

utils/logger.py

@@ -1,213 +0,0 @@
-import datetime
-import logging
-import time
-
-from .dist_util import get_dist_info, master_only
-
-initialized_logger = {}
-
-
-class AvgTimer():
-
-    def __init__(self, window=200):
-        self.window = window  # average window
-        self.current_time = 0
-        self.total_time = 0
-        self.count = 0
-        self.avg_time = 0
-        self.start()
-
-    def start(self):
-        self.start_time = self.tic = time.time()
-
-    def record(self):
-        self.count += 1
-        self.toc = time.time()
-        self.current_time = self.toc - self.tic
-        self.total_time += self.current_time
-        # calculate average time
-        self.avg_time = self.total_time / self.count
-
-        # reset
-        if self.count > self.window:
-            self.count = 0
-            self.total_time = 0
-
-        self.tic = time.time()
-
-    def get_current_time(self):
-        return self.current_time
-
-    def get_avg_time(self):
-        return self.avg_time
-
-
-class MessageLogger():
-    """Message logger for printing.
-
-    Args:
-        opt (dict): Config. It contains the following keys:
-            name (str): Exp name.
-            logger (dict): Contains 'print_freq' (str) for logger interval.
-            train (dict): Contains 'total_iter' (int) for total iters.
-            use_tb_logger (bool): Use tensorboard logger.
-        start_iter (int): Start iter. Default: 1.
-        tb_logger (obj:`tb_logger`): Tensorboard logger. Default： None.
-    """
-
-    def __init__(self, opt, start_iter=1, tb_logger=None):
-        self.exp_name = opt['name']
-        self.interval = opt['logger']['print_freq']
-        self.start_iter = start_iter
-        self.max_iters = opt['train']['total_iter']
-        self.use_tb_logger = opt['logger']['use_tb_logger']
-        self.tb_logger = tb_logger
-        self.start_time = time.time()
-        self.logger = get_root_logger()
-
-    def reset_start_time(self):
-        self.start_time = time.time()
-
-    @master_only
-    def __call__(self, log_vars):
-        """Format logging message.
-
-        Args:
-            log_vars (dict): It contains the following keys:
-                epoch (int): Epoch number.
-                iter (int): Current iter.
-                lrs (list): List for learning rates.
-
-                time (float): Iter time.
-                data_time (float): Data time for each iter.
-        """
-        # epoch, iter, learning rates
-        epoch = log_vars.pop('epoch')
-        current_iter = log_vars.pop('iter')
-        lrs = log_vars.pop('lrs')
-
-        message = (f'[{self.exp_name[:5]}..][epoch:{epoch:3d}, iter:{current_iter:8,d}, lr:(')
-        for v in lrs:
-            message += f'{v:.3e},'
-        message += ')] '
-
-        # time and estimated time
-        if 'time' in log_vars.keys():
-            iter_time = log_vars.pop('time')
-            data_time = log_vars.pop('data_time')
-
-            total_time = time.time() - self.start_time
-            time_sec_avg = total_time / (current_iter - self.start_iter + 1)
-            eta_sec = time_sec_avg * (self.max_iters - current_iter - 1)
-            eta_str = str(datetime.timedelta(seconds=int(eta_sec)))
-            message += f'[eta: {eta_str}, '
-            message += f'time (data): {iter_time:.3f} ({data_time:.3f})] '
-
-        # other items, especially losses
-        for k, v in log_vars.items():
-            message += f'{k}: {v:.4e} '
-            # tensorboard logger
-            if self.use_tb_logger and 'debug' not in self.exp_name:
-                if k.startswith('l_'):
-                    self.tb_logger.add_scalar(f'losses/{k}', v, current_iter)
-                else:
-                    self.tb_logger.add_scalar(k, v, current_iter)
-        self.logger.info(message)
-
-
-@master_only
-def init_tb_logger(log_dir):
-    from torch.utils.tensorboard import SummaryWriter
-    tb_logger = SummaryWriter(log_dir=log_dir)
-    return tb_logger
-
-
-@master_only
-def init_wandb_logger(opt):
-    """We now only use wandb to sync tensorboard log."""
-    import wandb
-    logger = get_root_logger()
-
-    project = opt['logger']['wandb']['project']
-    resume_id = opt['logger']['wandb'].get('resume_id')
-    if resume_id:
-        wandb_id = resume_id
-        resume = 'allow'
-        logger.warning(f'Resume wandb logger with id={wandb_id}.')
-    else:
-        wandb_id = wandb.util.generate_id()
-        resume = 'never'
-
-    wandb.init(id=wandb_id, resume=resume, name=opt['name'], config=opt, project=project, sync_tensorboard=True)
-
-    logger.info(f'Use wandb logger with id={wandb_id}; project={project}.')
-
-
-def get_root_logger(logger_name='basicsr', log_level=logging.INFO, log_file=None):
-    """Get the root logger.
-
-    The logger will be initialized if it has not been initialized. By default a
-    StreamHandler will be added. If `log_file` is specified, a FileHandler will
-    also be added.
-
-    Args:
-        logger_name (str): root logger name. Default: 'basicsr'.
-        log_file (str | None): The log filename. If specified, a FileHandler
-            will be added to the root logger.
-        log_level (int): The root logger level. Note that only the process of
-            rank 0 is affected, while other processes will set the level to
-            "Error" and be silent most of the time.
-
-    Returns:
-        logging.Logger: The root logger.
-    """
-    logger = logging.getLogger(logger_name)
-    # if the logger has been initialized, just return it
-    if logger_name in initialized_logger:
-        return logger
-
-    format_str = '%(asctime)s %(levelname)s: %(message)s'
-    stream_handler = logging.StreamHandler()
-    stream_handler.setFormatter(logging.Formatter(format_str))
-    logger.addHandler(stream_handler)
-    logger.propagate = False
-    rank, _ = get_dist_info()
-    if rank != 0:
-        logger.setLevel('ERROR')
-    elif log_file is not None:
-        logger.setLevel(log_level)
-        # add file handler
-        file_handler = logging.FileHandler(log_file, 'w')
-        file_handler.setFormatter(logging.Formatter(format_str))
-        file_handler.setLevel(log_level)
-        logger.addHandler(file_handler)
-    initialized_logger[logger_name] = True
-    return logger
-
-
-def get_env_info():
-    """Get environment information.
-
-    Currently, only log the software version.
-    """
-    import torch
-    import torchvision
-
-    from basicsr.version import __version__
-    msg = r"""
-                ____                _       _____  ____
-               / __ ) ____ _ _____ (_)_____/ ___/ / __ \
-              / __  |/ __ `// ___// // ___/\__ \ / /_/ /
-             / /_/ // /_/ /(__  )/ // /__ ___/ // _, _/
-            /_____/ \__,_//____//_/ \___//____//_/ |_|
-     ______                   __   __                 __      __
-    / ____/____   ____   ____/ /  / /   __  __ _____ / /__   / /
-   / / __ / __ \ / __ \ / __  /  / /   / / / // ___// //_/  / /
-  / /_/ // /_/ // /_/ // /_/ /  / /___/ /_/ // /__ / /<    /_/
-  \____/ \____/ \____/ \____/  /_____/\____/ \___//_/|_|  (_)
-    """
-    msg += ('\nVersion Information: '
-            f'\n\tBasicSR: {__version__}'
-            f'\n\tPyTorch: {torch.__version__}'
-            f'\n\tTorchVision: {torchvision.__version__}')
-    return msg

utils/matlab_functions.py

@@ -1,359 +0,0 @@
-import math
-import numpy as np
-import torch
-
-
-def cubic(x):
-    """cubic function used for calculate_weights_indices."""
-    absx = torch.abs(x)
-    absx2 = absx**2
-    absx3 = absx**3
-    return (1.5 * absx3 - 2.5 * absx2 + 1) * (
-        (absx <= 1).type_as(absx)) + (-0.5 * absx3 + 2.5 * absx2 - 4 * absx + 2) * (((absx > 1) *
-                                                                                     (absx <= 2)).type_as(absx))
-
-
-def calculate_weights_indices(in_length, out_length, scale, kernel, kernel_width, antialiasing):
-    """Calculate weights and indices, used for imresize function.
-
-    Args:
-        in_length (int): Input length.
-        out_length (int): Output length.
-        scale (float): Scale factor.
-        kernel_width (int): Kernel width.
-        antialisaing (bool): Whether to apply anti-aliasing when downsampling.
-    """
-
-    if (scale < 1) and antialiasing:
-        # Use a modified kernel (larger kernel width) to simultaneously
-        # interpolate and antialias
-        kernel_width = kernel_width / scale
-
-    # Output-space coordinates
-    x = torch.linspace(1, out_length, out_length)
-
-    # Input-space coordinates. Calculate the inverse mapping such that 0.5
-    # in output space maps to 0.5 in input space, and 0.5 + scale in output
-    # space maps to 1.5 in input space.
-    u = x / scale + 0.5 * (1 - 1 / scale)
-
-    # What is the left-most pixel that can be involved in the computation?
-    left = torch.floor(u - kernel_width / 2)
-
-    # What is the maximum number of pixels that can be involved in the
-    # computation?  Note: it's OK to use an extra pixel here; if the
-    # corresponding weights are all zero, it will be eliminated at the end
-    # of this function.
-    p = math.ceil(kernel_width) + 2
-
-    # The indices of the input pixels involved in computing the k-th output
-    # pixel are in row k of the indices matrix.
-    indices = left.view(out_length, 1).expand(out_length, p) + torch.linspace(0, p - 1, p).view(1, p).expand(
-        out_length, p)
-
-    # The weights used to compute the k-th output pixel are in row k of the
-    # weights matrix.
-    distance_to_center = u.view(out_length, 1).expand(out_length, p) - indices
-
-    # apply cubic kernel
-    if (scale < 1) and antialiasing:
-        weights = scale * cubic(distance_to_center * scale)
-    else:
-        weights = cubic(distance_to_center)
-
-    # Normalize the weights matrix so that each row sums to 1.
-    weights_sum = torch.sum(weights, 1).view(out_length, 1)
-    weights = weights / weights_sum.expand(out_length, p)
-
-    # If a column in weights is all zero, get rid of it. only consider the
-    # first and last column.
-    weights_zero_tmp = torch.sum((weights == 0), 0)
-    if not math.isclose(weights_zero_tmp[0], 0, rel_tol=1e-6):
-        indices = indices.narrow(1, 1, p - 2)
-        weights = weights.narrow(1, 1, p - 2)
-    if not math.isclose(weights_zero_tmp[-1], 0, rel_tol=1e-6):
-        indices = indices.narrow(1, 0, p - 2)
-        weights = weights.narrow(1, 0, p - 2)
-    weights = weights.contiguous()
-    indices = indices.contiguous()
-    sym_len_s = -indices.min() + 1
-    sym_len_e = indices.max() - in_length
-    indices = indices + sym_len_s - 1
-    return weights, indices, int(sym_len_s), int(sym_len_e)
-
-
-@torch.no_grad()
-def imresize(img, scale, antialiasing=True):
-    """imresize function same as MATLAB.
-
-    It now only supports bicubic.
-    The same scale applies for both height and width.
-
-    Args:
-        img (Tensor | Numpy array):
-            Tensor: Input image with shape (c, h, w), [0, 1] range.
-            Numpy: Input image with shape (h, w, c), [0, 1] range.
-        scale (float): Scale factor. The same scale applies for both height
-            and width.
-        antialisaing (bool): Whether to apply anti-aliasing when downsampling.
-            Default: True.
-
-    Returns:
-        Tensor: Output image with shape (c, h, w), [0, 1] range, w/o round.
-    """
-    squeeze_flag = False
-    if type(img).__module__ == np.__name__:  # numpy type
-        numpy_type = True
-        if img.ndim == 2:
-            img = img[:, :, None]
-            squeeze_flag = True
-        img = torch.from_numpy(img.transpose(2, 0, 1)).float()
-    else:
-        numpy_type = False
-        if img.ndim == 2:
-            img = img.unsqueeze(0)
-            squeeze_flag = True
-
-    in_c, in_h, in_w = img.size()
-    out_h, out_w = math.ceil(in_h * scale), math.ceil(in_w * scale)
-    kernel_width = 4
-    kernel = 'cubic'
-
-    # get weights and indices
-    weights_h, indices_h, sym_len_hs, sym_len_he = calculate_weights_indices(in_h, out_h, scale, kernel, kernel_width,
-                                                                             antialiasing)
-    weights_w, indices_w, sym_len_ws, sym_len_we = calculate_weights_indices(in_w, out_w, scale, kernel, kernel_width,
-                                                                             antialiasing)
-    # process H dimension
-    # symmetric copying
-    img_aug = torch.FloatTensor(in_c, in_h + sym_len_hs + sym_len_he, in_w)
-    img_aug.narrow(1, sym_len_hs, in_h).copy_(img)
-
-    sym_patch = img[:, :sym_len_hs, :]
-    inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long()
-    sym_patch_inv = sym_patch.index_select(1, inv_idx)
-    img_aug.narrow(1, 0, sym_len_hs).copy_(sym_patch_inv)
-
-    sym_patch = img[:, -sym_len_he:, :]
-    inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long()
-    sym_patch_inv = sym_patch.index_select(1, inv_idx)
-    img_aug.narrow(1, sym_len_hs + in_h, sym_len_he).copy_(sym_patch_inv)
-
-    out_1 = torch.FloatTensor(in_c, out_h, in_w)
-    kernel_width = weights_h.size(1)
-    for i in range(out_h):
-        idx = int(indices_h[i][0])
-        for j in range(in_c):
-            out_1[j, i, :] = img_aug[j, idx:idx + kernel_width, :].transpose(0, 1).mv(weights_h[i])
-
-    # process W dimension
-    # symmetric copying
-    out_1_aug = torch.FloatTensor(in_c, out_h, in_w + sym_len_ws + sym_len_we)
-    out_1_aug.narrow(2, sym_len_ws, in_w).copy_(out_1)
-
-    sym_patch = out_1[:, :, :sym_len_ws]
-    inv_idx = torch.arange(sym_patch.size(2) - 1, -1, -1).long()
-    sym_patch_inv = sym_patch.index_select(2, inv_idx)
-    out_1_aug.narrow(2, 0, sym_len_ws).copy_(sym_patch_inv)
-
-    sym_patch = out_1[:, :, -sym_len_we:]
-    inv_idx = torch.arange(sym_patch.size(2) - 1, -1, -1).long()
-    sym_patch_inv = sym_patch.index_select(2, inv_idx)
-    out_1_aug.narrow(2, sym_len_ws + in_w, sym_len_we).copy_(sym_patch_inv)
-
-    out_2 = torch.FloatTensor(in_c, out_h, out_w)
-    kernel_width = weights_w.size(1)
-    for i in range(out_w):
-        idx = int(indices_w[i][0])
-        for j in range(in_c):
-            out_2[j, :, i] = out_1_aug[j, :, idx:idx + kernel_width].mv(weights_w[i])
-
-    if squeeze_flag:
-        out_2 = out_2.squeeze(0)
-    if numpy_type:
-        out_2 = out_2.numpy()
-        if not squeeze_flag:
-            out_2 = out_2.transpose(1, 2, 0)
-
-    return out_2
-
-
-def rgb2ycbcr(img, y_only=False):
-    """Convert a RGB image to YCbCr image.
-
-    This function produces the same results as Matlab's `rgb2ycbcr` function.
-    It implements the ITU-R BT.601 conversion for standard-definition
-    television. See more details in
-    https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion.
-
-    It differs from a similar function in cv2.cvtColor: `RGB <-> YCrCb`.
-    In OpenCV, it implements a JPEG conversion. See more details in
-    https://en.wikipedia.org/wiki/YCbCr#JPEG_conversion.
-
-    Args:
-        img (ndarray): The input image. It accepts:
-            1. np.uint8 type with range [0, 255];
-            2. np.float32 type with range [0, 1].
-        y_only (bool): Whether to only return Y channel. Default: False.
-
-    Returns:
-        ndarray: The converted YCbCr image. The output image has the same type
-            and range as input image.
-    """
-    img_type = img.dtype
-    img = _convert_input_type_range(img)
-    if y_only:
-        out_img = np.dot(img, [65.481, 128.553, 24.966]) + 16.0
-    else:
-        out_img = np.matmul(
-            img, [[65.481, -37.797, 112.0], [128.553, -74.203, -93.786], [24.966, 112.0, -18.214]]) + [16, 128, 128]
-    out_img = _convert_output_type_range(out_img, img_type)
-    return out_img
-
-
-def bgr2ycbcr(img, y_only=False):
-    """Convert a BGR image to YCbCr image.
-
-    The bgr version of rgb2ycbcr.
-    It implements the ITU-R BT.601 conversion for standard-definition
-    television. See more details in
-    https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion.
-
-    It differs from a similar function in cv2.cvtColor: `BGR <-> YCrCb`.
-    In OpenCV, it implements a JPEG conversion. See more details in
-    https://en.wikipedia.org/wiki/YCbCr#JPEG_conversion.
-
-    Args:
-        img (ndarray): The input image. It accepts:
-            1. np.uint8 type with range [0, 255];
-            2. np.float32 type with range [0, 1].
-        y_only (bool): Whether to only return Y channel. Default: False.
-
-    Returns:
-        ndarray: The converted YCbCr image. The output image has the same type
-            and range as input image.
-    """
-    img_type = img.dtype
-    img = _convert_input_type_range(img)
-    if y_only:
-        out_img = np.dot(img, [24.966, 128.553, 65.481]) + 16.0
-    else:
-        out_img = np.matmul(
-            img, [[24.966, 112.0, -18.214], [128.553, -74.203, -93.786], [65.481, -37.797, 112.0]]) + [16, 128, 128]
-    out_img = _convert_output_type_range(out_img, img_type)
-    return out_img
-
-
-def ycbcr2rgb(img):
-    """Convert a YCbCr image to RGB image.
-
-    This function produces the same results as Matlab's ycbcr2rgb function.
-    It implements the ITU-R BT.601 conversion for standard-definition
-    television. See more details in
-    https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion.
-
-    It differs from a similar function in cv2.cvtColor: `YCrCb <-> RGB`.
-    In OpenCV, it implements a JPEG conversion. See more details in
-    https://en.wikipedia.org/wiki/YCbCr#JPEG_conversion.
-
-    Args:
-        img (ndarray): The input image. It accepts:
-            1. np.uint8 type with range [0, 255];
-            2. np.float32 type with range [0, 1].
-
-    Returns:
-        ndarray: The converted RGB image. The output image has the same type
-            and range as input image.
-    """
-    img_type = img.dtype
-    img = _convert_input_type_range(img) * 255
-    out_img = np.matmul(img, [[0.00456621, 0.00456621, 0.00456621], [0, -0.00153632, 0.00791071],
-                              [0.00625893, -0.00318811, 0]]) * 255.0 + [-222.921, 135.576, -276.836]  # noqa: E126
-    out_img = _convert_output_type_range(out_img, img_type)
-    return out_img
-
-
-def ycbcr2bgr(img):
-    """Convert a YCbCr image to BGR image.
-
-    The bgr version of ycbcr2rgb.
-    It implements the ITU-R BT.601 conversion for standard-definition
-    television. See more details in
-    https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion.
-
-    It differs from a similar function in cv2.cvtColor: `YCrCb <-> BGR`.
-    In OpenCV, it implements a JPEG conversion. See more details in
-    https://en.wikipedia.org/wiki/YCbCr#JPEG_conversion.
-
-    Args:
-        img (ndarray): The input image. It accepts:
-            1. np.uint8 type with range [0, 255];
-            2. np.float32 type with range [0, 1].
-
-    Returns:
-        ndarray: The converted BGR image. The output image has the same type
-            and range as input image.
-    """
-    img_type = img.dtype
-    img = _convert_input_type_range(img) * 255
-    out_img = np.matmul(img, [[0.00456621, 0.00456621, 0.00456621], [0.00791071, -0.00153632, 0],
-                              [0, -0.00318811, 0.00625893]]) * 255.0 + [-276.836, 135.576, -222.921]  # noqa: E126
-    out_img = _convert_output_type_range(out_img, img_type)
-    return out_img
-
-
-def _convert_input_type_range(img):
-    """Convert the type and range of the input image.
-
-    It converts the input image to np.float32 type and range of [0, 1].
-    It is mainly used for pre-processing the input image in colorspace
-    conversion functions such as rgb2ycbcr and ycbcr2rgb.
-
-    Args:
-        img (ndarray): The input image. It accepts:
-            1. np.uint8 type with range [0, 255];
-            2. np.float32 type with range [0, 1].
-
-    Returns:
-        (ndarray): The converted image with type of np.float32 and range of
-            [0, 1].
-    """
-    img_type = img.dtype
-    img = img.astype(np.float32)
-    if img_type == np.float32:
-        pass
-    elif img_type == np.uint8:
-        img /= 255.
-    else:
-        raise TypeError(f'The img type should be np.float32 or np.uint8, but got {img_type}')
-    return img
-
-
-def _convert_output_type_range(img, dst_type):
-    """Convert the type and range of the image according to dst_type.
-
-    It converts the image to desired type and range. If `dst_type` is np.uint8,
-    images will be converted to np.uint8 type with range [0, 255]. If
-    `dst_type` is np.float32, it converts the image to np.float32 type with
-    range [0, 1].
-    It is mainly used for post-processing images in colorspace conversion
-    functions such as rgb2ycbcr and ycbcr2rgb.
-
-    Args:
-        img (ndarray): The image to be converted with np.float32 type and
-            range [0, 255].
-        dst_type (np.uint8 | np.float32): If dst_type is np.uint8, it
-            converts the image to np.uint8 type with range [0, 255]. If
-            dst_type is np.float32, it converts the image to np.float32 type
-            with range [0, 1].
-
-    Returns:
-        (ndarray): The converted image with desired type and range.
-    """
-    if dst_type not in (np.uint8, np.float32):
-        raise TypeError(f'The dst_type should be np.float32 or np.uint8, but got {dst_type}')
-    if dst_type == np.uint8:
-        img = img.round()
-    else:
-        img /= 255.
-    return img.astype(dst_type)

utils/misc.py

@@ -1,141 +0,0 @@
-import numpy as np
-import os
-import random
-import time
-import torch
-from os import path as osp
-
-from .dist_util import master_only
-
-
-def set_random_seed(seed):
-    """Set random seeds."""
-    random.seed(seed)
-    np.random.seed(seed)
-    torch.manual_seed(seed)
-    torch.cuda.manual_seed(seed)
-    torch.cuda.manual_seed_all(seed)
-
-
-def get_time_str():
-    return time.strftime('%Y%m%d_%H%M%S', time.localtime())
-
-
-def mkdir_and_rename(path):
-    """mkdirs. If path exists, rename it with timestamp and create a new one.
-
-    Args:
-        path (str): Folder path.
-    """
-    if osp.exists(path):
-        new_name = path + '_archived_' + get_time_str()
-        print(f'Path already exists. Rename it to {new_name}', flush=True)
-        os.rename(path, new_name)
-    os.makedirs(path, exist_ok=True)
-
-
-@master_only
-def make_exp_dirs(opt):
-    """Make dirs for experiments."""
-    path_opt = opt['path'].copy()
-    if opt['is_train']:
-        mkdir_and_rename(path_opt.pop('experiments_root'))
-    else:
-        mkdir_and_rename(path_opt.pop('results_root'))
-    for key, path in path_opt.items():
-        if ('strict_load' in key) or ('pretrain_network' in key) or ('resume' in key) or ('param_key' in key):
-            continue
-        else:
-            os.makedirs(path, exist_ok=True)
-
-
-def scandir(dir_path, suffix=None, recursive=False, full_path=False):
-    """Scan a directory to find the interested files.
-
-    Args:
-        dir_path (str): Path of the directory.
-        suffix (str | tuple(str), optional): File suffix that we are
-            interested in. Default: None.
-        recursive (bool, optional): If set to True, recursively scan the
-            directory. Default: False.
-        full_path (bool, optional): If set to True, include the dir_path.
-            Default: False.
-
-    Returns:
-        A generator for all the interested files with relative paths.
-    """
-
-    if (suffix is not None) and not isinstance(suffix, (str, tuple)):
-        raise TypeError('"suffix" must be a string or tuple of strings')
-
-    root = dir_path
-
-    def _scandir(dir_path, suffix, recursive):
-        for entry in os.scandir(dir_path):
-            if not entry.name.startswith('.') and entry.is_file():
-                if full_path:
-                    return_path = entry.path
-                else:
-                    return_path = osp.relpath(entry.path, root)
-
-                if suffix is None:
-                    yield return_path
-                elif return_path.endswith(suffix):
-                    yield return_path
-            else:
-                if recursive:
-                    yield from _scandir(entry.path, suffix=suffix, recursive=recursive)
-                else:
-                    continue
-
-    return _scandir(dir_path, suffix=suffix, recursive=recursive)
-
-
-def check_resume(opt, resume_iter):
-    """Check resume states and pretrain_network paths.
-
-    Args:
-        opt (dict): Options.
-        resume_iter (int): Resume iteration.
-    """
-    if opt['path']['resume_state']:
-        # get all the networks
-        networks = [key for key in opt.keys() if key.startswith('network_')]
-        flag_pretrain = False
-        for network in networks:
-            if opt['path'].get(f'pretrain_{network}') is not None:
-                flag_pretrain = True
-        if flag_pretrain:
-            print('pretrain_network path will be ignored during resuming.')
-        # set pretrained model paths
-        for network in networks:
-            name = f'pretrain_{network}'
-            basename = network.replace('network_', '')
-            if opt['path'].get('ignore_resume_networks') is None or (network
-                                                                     not in opt['path']['ignore_resume_networks']):
-                opt['path'][name] = osp.join(opt['path']['models'], f'net_{basename}_{resume_iter}.pth')
-                print(f"Set {name} to {opt['path'][name]}")
-
-        # change param_key to params in resume
-        param_keys = [key for key in opt['path'].keys() if key.startswith('param_key')]
-        for param_key in param_keys:
-            if opt['path'][param_key] == 'params_ema':
-                opt['path'][param_key] = 'params'
-                print(f'Set {param_key} to params')
-
-
-def sizeof_fmt(size, suffix='B'):
-    """Get human readable file size.
-
-    Args:
-        size (int): File size.
-        suffix (str): Suffix. Default: 'B'.
-
-    Return:
-        str: Formatted file siz.
-    """
-    for unit in ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z']:
-        if abs(size) < 1024.0:
-            return f'{size:3.1f} {unit}{suffix}'
-        size /= 1024.0
-    return f'{size:3.1f} Y{suffix}'

utils/options.py

@@ -1,194 +0,0 @@
-import argparse
-import random
-import torch
-import yaml
-from collections import OrderedDict
-from os import path as osp
-
-from basicsr.utils import set_random_seed
-from basicsr.utils.dist_util import get_dist_info, init_dist, master_only
-
-
-def ordered_yaml():
-    """Support OrderedDict for yaml.
-
-    Returns:
-        yaml Loader and Dumper.
-    """
-    try:
-        from yaml import CDumper as Dumper
-        from yaml import CLoader as Loader
-    except ImportError:
-        from yaml import Dumper, Loader
-
-    _mapping_tag = yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG
-
-    def dict_representer(dumper, data):
-        return dumper.represent_dict(data.items())
-
-    def dict_constructor(loader, node):
-        return OrderedDict(loader.construct_pairs(node))
-
-    Dumper.add_representer(OrderedDict, dict_representer)
-    Loader.add_constructor(_mapping_tag, dict_constructor)
-    return Loader, Dumper
-
-
-def dict2str(opt, indent_level=1):
-    """dict to string for printing options.
-
-    Args:
-        opt (dict): Option dict.
-        indent_level (int): Indent level. Default: 1.
-
-    Return:
-        (str): Option string for printing.
-    """
-    msg = '\n'
-    for k, v in opt.items():
-        if isinstance(v, dict):
-            msg += ' ' * (indent_level * 2) + k + ':['
-            msg += dict2str(v, indent_level + 1)
-            msg += ' ' * (indent_level * 2) + ']\n'
-        else:
-            msg += ' ' * (indent_level * 2) + k + ': ' + str(v) + '\n'
-    return msg
-
-
-def _postprocess_yml_value(value):
-    # None
-    if value == '~' or value.lower() == 'none':
-        return None
-    # bool
-    if value.lower() == 'true':
-        return True
-    elif value.lower() == 'false':
-        return False
-    # !!float number
-    if value.startswith('!!float'):
-        return float(value.replace('!!float', ''))
-    # number
-    if value.isdigit():
-        return int(value)
-    elif value.replace('.', '', 1).isdigit() and value.count('.') < 2:
-        return float(value)
-    # list
-    if value.startswith('['):
-        return eval(value)
-    # str
-    return value
-
-
-def parse_options(root_path, is_train=True):
-    parser = argparse.ArgumentParser()
-    parser.add_argument('-opt', type=str, required=True, help='Path to option YAML file.')
-    parser.add_argument('--launcher', choices=['none', 'pytorch', 'slurm'], default='none', help='job launcher')
-    parser.add_argument('--auto_resume', action='store_true')
-    parser.add_argument('--debug', action='store_true')
-    parser.add_argument('--local_rank', type=int, default=0)
-    parser.add_argument(
-        '--force_yml', nargs='+', default=None, help='Force to update yml files. Examples: train:ema_decay=0.999')
-    args = parser.parse_args()
-
-    # parse yml to dict
-    with open(args.opt, mode='r') as f:
-        opt = yaml.load(f, Loader=ordered_yaml()[0])
-
-    # distributed settings
-    if args.launcher == 'none':
-        opt['dist'] = False
-        print('Disable distributed.', flush=True)
-    else:
-        opt['dist'] = True
-        if args.launcher == 'slurm' and 'dist_params' in opt:
-            init_dist(args.launcher, **opt['dist_params'])
-        else:
-            init_dist(args.launcher)
-    opt['rank'], opt['world_size'] = get_dist_info()
-
-    # random seed
-    seed = opt.get('manual_seed')
-    if seed is None:
-        seed = random.randint(1, 10000)
-        opt['manual_seed'] = seed
-    set_random_seed(seed + opt['rank'])
-
-    # force to update yml options
-    if args.force_yml is not None:
-        for entry in args.force_yml:
-            # now do not support creating new keys
-            keys, value = entry.split('=')
-            keys, value = keys.strip(), value.strip()
-            value = _postprocess_yml_value(value)
-            eval_str = 'opt'
-            for key in keys.split(':'):
-                eval_str += f'["{key}"]'
-            eval_str += '=value'
-            # using exec function
-            exec(eval_str)
-
-    opt['auto_resume'] = args.auto_resume
-    opt['is_train'] = is_train
-
-    # debug setting
-    if args.debug and not opt['name'].startswith('debug'):
-        opt['name'] = 'debug_' + opt['name']
-
-    if opt['num_gpu'] == 'auto':
-        opt['num_gpu'] = torch.cuda.device_count()
-
-    # datasets
-    for phase, dataset in opt['datasets'].items():
-        # for multiple datasets, e.g., val_1, val_2; test_1, test_2
-        phase = phase.split('_')[0]
-        dataset['phase'] = phase
-        if 'scale' in opt:
-            dataset['scale'] = opt['scale']
-        if dataset.get('dataroot_gt') is not None:
-            dataset['dataroot_gt'] = osp.expanduser(dataset['dataroot_gt'])
-        if dataset.get('dataroot_lq') is not None:
-            dataset['dataroot_lq'] = osp.expanduser(dataset['dataroot_lq'])
-
-    # paths
-    for key, val in opt['path'].items():
-        if (val is not None) and ('resume_state' in key or 'pretrain_network' in key):
-            opt['path'][key] = osp.expanduser(val)
-
-    if is_train:
-        experiments_root = osp.join(root_path, 'experiments', opt['name'])
-        opt['path']['experiments_root'] = experiments_root
-        opt['path']['models'] = osp.join(experiments_root, 'models')
-        opt['path']['training_states'] = osp.join(experiments_root, 'training_states')
-        opt['path']['log'] = experiments_root
-        opt['path']['visualization'] = osp.join(experiments_root, 'visualization')
-
-        # change some options for debug mode
-        if 'debug' in opt['name']:
-            if 'val' in opt:
-                opt['val']['val_freq'] = 8
-            opt['logger']['print_freq'] = 1
-            opt['logger']['save_checkpoint_freq'] = 8
-    else:  # test
-        results_root = osp.join(root_path, 'results', opt['name'])
-        opt['path']['results_root'] = results_root
-        opt['path']['log'] = results_root
-        opt['path']['visualization'] = osp.join(results_root, 'visualization')
-
-    return opt, args
-
-
-@master_only
-def copy_opt_file(opt_file, experiments_root):
-    # copy the yml file to the experiment root
-    import sys
-    import time
-    from shutil import copyfile
-    cmd = ' '.join(sys.argv)
-    filename = osp.join(experiments_root, osp.basename(opt_file))
-    copyfile(opt_file, filename)
-
-    with open(filename, 'r+') as f:
-        lines = f.readlines()
-        lines.insert(0, f'# GENERATE TIME: {time.asctime()}\n# CMD:\n# {cmd}\n\n')
-        f.seek(0)
-        f.writelines(lines)

utils/registry.py

@@ -1,82 +0,0 @@
-# Modified from: https://github.com/facebookresearch/fvcore/blob/master/fvcore/common/registry.py  # noqa: E501
-
-
-class Registry():
-    """
-    The registry that provides name -> object mapping, to support third-party
-    users' custom modules.
-
-    To create a registry (e.g. a backbone registry):
-
-    .. code-block:: python
-
-        BACKBONE_REGISTRY = Registry('BACKBONE')
-
-    To register an object:
-
-    .. code-block:: python
-
-        @BACKBONE_REGISTRY.register()
-        class MyBackbone():
-            ...
-
-    Or:
-
-    .. code-block:: python
-
-        BACKBONE_REGISTRY.register(MyBackbone)
-    """
-
-    def __init__(self, name):
-        """
-        Args:
-            name (str): the name of this registry
-        """
-        self._name = name
-        self._obj_map = {}
-
-    def _do_register(self, name, obj):
-        assert (name not in self._obj_map), (f"An object named '{name}' was already registered "
-                                             f"in '{self._name}' registry!")
-        self._obj_map[name] = obj
-
-    def register(self, obj=None):
-        """
-        Register the given object under the the name `obj.__name__`.
-        Can be used as either a decorator or not.
-        See docstring of this class for usage.
-        """
-        if obj is None:
-            # used as a decorator
-            def deco(func_or_class):
-                name = func_or_class.__name__
-                self._do_register(name, func_or_class)
-                return func_or_class
-
-            return deco
-
-        # used as a function call
-        name = obj.__name__
-        self._do_register(name, obj)
-
-    def get(self, name):
-        ret = self._obj_map.get(name)
-        if ret is None:
-            raise KeyError(f"No object named '{name}' found in '{self._name}' registry!")
-        return ret
-
-    def __contains__(self, name):
-        return name in self._obj_map
-
-    def __iter__(self):
-        return iter(self._obj_map.items())
-
-    def keys(self):
-        return self._obj_map.keys()
-
-
-DATASET_REGISTRY = Registry('dataset')
-ARCH_REGISTRY = Registry('arch')
-MODEL_REGISTRY = Registry('model')
-LOSS_REGISTRY = Registry('loss')
-METRIC_REGISTRY = Registry('metric')