| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| import collections.abc |
| import itertools |
| import random |
| from ast import literal_eval |
| from distutils.util import strtobool |
| from typing import Any, Callable, Optional, Sequence, Tuple, Union |
|
|
| import numpy as np |
| import torch |
|
|
| _seed = None |
|
|
|
|
| def zip_with(op, *vals, mapfunc=map): |
| """ |
| Map `op`, using `mapfunc`, to each tuple derived from zipping the iterables in `vals`. |
| """ |
| return mapfunc(op, zip(*vals)) |
|
|
|
|
| def star_zip_with(op, *vals): |
| """ |
| Use starmap as the mapping function in zipWith. |
| """ |
| return zip_with(op, *vals, mapfunc=itertools.starmap) |
|
|
|
|
| def first(iterable, default=None): |
| """ |
| Returns the first item in the given iterable or `default` if empty, meaningful mostly with 'for' expressions. |
| """ |
| for i in iterable: |
| return i |
| return default |
|
|
|
|
| def issequenceiterable(obj: Any) -> bool: |
| """ |
| Determine if the object is an iterable sequence and is not a string. |
| """ |
| return isinstance(obj, collections.abc.Iterable) and not isinstance(obj, str) |
|
|
|
|
| def ensure_tuple(vals: Any) -> Tuple[Any, ...]: |
| """ |
| Returns a tuple of `vals`. |
| """ |
| if not issequenceiterable(vals): |
| vals = (vals,) |
|
|
| return tuple(vals) |
|
|
|
|
| def ensure_tuple_size(tup: Any, dim: int, pad_val: Any = 0) -> Tuple[Any, ...]: |
| """ |
| Returns a copy of `tup` with `dim` values by either shortened or padded with `pad_val` as necessary. |
| """ |
| tup = ensure_tuple(tup) + (pad_val,) * dim |
| return tuple(tup[:dim]) |
|
|
|
|
| def ensure_tuple_rep(tup: Any, dim: int) -> Tuple[Any, ...]: |
| """ |
| Returns a copy of `tup` with `dim` values by either shortened or duplicated input. |
| |
| Raises: |
| ValueError: When ``tup`` is a sequence and ``tup`` length is not ``dim``. |
| |
| Examples:: |
| |
| >>> ensure_tuple_rep(1, 3) |
| (1, 1, 1) |
| >>> ensure_tuple_rep(None, 3) |
| (None, None, None) |
| >>> ensure_tuple_rep('test', 3) |
| ('test', 'test', 'test') |
| >>> ensure_tuple_rep([1, 2, 3], 3) |
| (1, 2, 3) |
| >>> ensure_tuple_rep(range(3), 3) |
| (0, 1, 2) |
| >>> ensure_tuple_rep([1, 2], 3) |
| ValueError: Sequence must have length 3, got length 2. |
| |
| """ |
| if not issequenceiterable(tup): |
| return (tup,) * dim |
| elif len(tup) == dim: |
| return tuple(tup) |
|
|
| raise ValueError(f"Sequence must have length {dim}, got {len(tup)}.") |
|
|
|
|
| def fall_back_tuple(user_provided: Any, default: Sequence, func: Callable = lambda x: x and x > 0) -> Tuple[Any, ...]: |
| """ |
| Refine `user_provided` according to the `default`, and returns as a validated tuple. |
| |
| The validation is done for each element in `user_provided` using `func`. |
| If `func(user_provided[idx])` returns False, the corresponding `default[idx]` will be used |
| as the fallback. |
| |
| Typically used when `user_provided` is a tuple of window size provided by the user, |
| `default` is defined by data, this function returns an updated `user_provided` with its non-positive |
| components replaced by the corresponding components from `default`. |
| |
| Args: |
| user_provided: item to be validated. |
| default: a sequence used to provided the fallbacks. |
| func: a Callable to validate every components of `user_provided`. |
| |
| Examples:: |
| |
| >>> fall_back_tuple((1, 2), (32, 32)) |
| (1, 2) |
| >>> fall_back_tuple(None, (32, 32)) |
| (32, 32) |
| >>> fall_back_tuple((-1, 10), (32, 32)) |
| (32, 10) |
| >>> fall_back_tuple((-1, None), (32, 32)) |
| (32, 32) |
| >>> fall_back_tuple((1, None), (32, 32)) |
| (1, 32) |
| >>> fall_back_tuple(0, (32, 32)) |
| (32, 32) |
| >>> fall_back_tuple(range(3), (32, 64, 48)) |
| (32, 1, 2) |
| >>> fall_back_tuple([0], (32, 32)) |
| ValueError: Sequence must have length 2, got length 1. |
| |
| """ |
| ndim = len(default) |
| user = ensure_tuple_rep(user_provided, ndim) |
| return tuple( |
| user_c if func(user_c) else default_c for default_c, user_c in zip(default, user) |
| ) |
|
|
|
|
| def is_scalar_tensor(val: Any) -> bool: |
| if torch.is_tensor(val) and val.ndim == 0: |
| return True |
| return False |
|
|
|
|
| def is_scalar(val: Any) -> bool: |
| if torch.is_tensor(val) and val.ndim == 0: |
| return True |
| return bool(np.isscalar(val)) |
|
|
|
|
| def progress_bar(index: int, count: int, desc: Optional[str] = None, bar_len: int = 30, newline: bool = False) -> None: |
| """print a progress bar to track some time consuming task. |
| |
| Args: |
| index: current satus in progress. |
| count: total steps of the progress. |
| desc: description of the progress bar, if not None, show before the progress bar. |
| bar_len: the total length of the bar on screen, default is 30 char. |
| newline: whether to print in a new line for every index. |
| """ |
| end = "\r" if newline is False else "\r\n" |
| filled_len = int(bar_len * index // count) |
| bar = f"{desc} " if desc is not None else "" |
| bar += "[" + "=" * filled_len + " " * (bar_len - filled_len) + "]" |
| print(f"{index}/{count} {bar}", end=end) |
| if index == count: |
| print("") |
|
|
|
|
| def get_seed() -> Optional[int]: |
| return _seed |
|
|
|
|
| def set_determinism( |
| seed: Optional[int] = np.iinfo(np.int32).max, |
| additional_settings: Optional[Union[Sequence[Callable[[int], Any]], Callable[[int], Any]]] = None, |
| ) -> None: |
| """ |
| Set random seed for modules to enable or disable deterministic training. |
| |
| Args: |
| seed: the random seed to use, default is np.iinfo(np.int32).max. |
| It is recommended to set a large seed, i.e. a number that has a good balance |
| of 0 and 1 bits. Avoid having many 0 bits in the seed. |
| if set to None, will disable deterministic training. |
| additional_settings: additional settings |
| that need to set random seed. |
| |
| """ |
| if seed is None: |
| |
| seed_ = torch.default_generator.seed() % (np.iinfo(np.int32).max + 1) |
| if not torch.cuda._is_in_bad_fork(): |
| torch.cuda.manual_seed_all(seed_) |
| else: |
| torch.manual_seed(seed) |
|
|
| global _seed |
| _seed = seed |
| random.seed(seed) |
| np.random.seed(seed) |
|
|
| if additional_settings is not None: |
| additional_settings = ensure_tuple(additional_settings) |
| for func in additional_settings: |
| func(seed) |
|
|
| if seed is not None: |
| torch.backends.cudnn.deterministic = True |
| torch.backends.cudnn.benchmark = False |
| else: |
| torch.backends.cudnn.deterministic = False |
|
|
|
|
| def list_to_dict(items): |
| """ |
| To convert a list of "key=value" pairs into a dictionary. |
| For examples: items: `["a=1", "b=2", "c=3"]`, return: {"a": "1", "b": "2", "c": "3"}. |
| If no "=" in the pair, use None as the value, for example: ["a"], return: {"a": None}. |
| Note that it will remove the blanks around keys and values. |
| |
| """ |
|
|
| def _parse_var(s): |
| items = s.split("=", maxsplit=1) |
| key = items[0].strip(" \n\r\t'") |
| value = None |
| if len(items) > 1: |
| value = items[1].strip(" \n\r\t'") |
| return key, value |
|
|
| d = dict() |
| if items: |
| for item in items: |
| key, value = _parse_var(item) |
|
|
| try: |
| if key in d: |
| raise KeyError(f"encounter duplicated key {key}.") |
| d[key] = literal_eval(value) |
| except ValueError: |
| try: |
| d[key] = bool(strtobool(str(value))) |
| except ValueError: |
| d[key] = value |
| return d |
|
|
