From bc4a22bf2d1d33f349cb0ef99e2ec0ee1f000409 Mon Sep 17 00:00:00 2001 From: spacepxl Date: Sun, 26 May 2024 15:37:15 -0400 Subject: [PATCH] initial functional version --- __init__.py | 10 + dnnlib/__init__.py | 9 + dnnlib/util.py | 491 +++++++++ nodes.py | 105 ++ requirements.txt | 3 + torch_utils/__init__.py | 9 + torch_utils/custom_ops.py | 157 +++ torch_utils/misc.py | 266 +++++ torch_utils/ops/__init__.py | 9 + torch_utils/ops/bias_act.cpp | 99 ++ torch_utils/ops/bias_act.cu | 173 ++++ torch_utils/ops/bias_act.h | 38 + torch_utils/ops/bias_act.py | 209 ++++ torch_utils/ops/conv2d_gradfix.py | 203 ++++ torch_utils/ops/conv2d_resample.py | 143 +++ torch_utils/ops/filtered_lrelu.cpp | 300 ++++++ torch_utils/ops/filtered_lrelu.cu | 1284 ++++++++++++++++++++++++ torch_utils/ops/filtered_lrelu.h | 90 ++ torch_utils/ops/filtered_lrelu.py | 274 +++++ torch_utils/ops/filtered_lrelu_ns.cu | 27 + torch_utils/ops/filtered_lrelu_rd.cu | 27 + torch_utils/ops/filtered_lrelu_wr.cu | 27 + torch_utils/ops/fma.py | 60 ++ torch_utils/ops/grid_sample_gradfix.py | 86 ++ torch_utils/ops/upfirdn2d.cpp | 107 ++ torch_utils/ops/upfirdn2d.cu | 384 +++++++ torch_utils/ops/upfirdn2d.h | 59 ++ torch_utils/ops/upfirdn2d.py | 389 +++++++ torch_utils/persistence.py | 251 +++++ torch_utils/training_stats.py | 268 +++++ workflow.png | Bin 0 -> 479682 bytes 31 files changed, 5557 insertions(+) create mode 100644 __init__.py create mode 100644 dnnlib/__init__.py create mode 100644 dnnlib/util.py create mode 100644 nodes.py create mode 100644 requirements.txt create mode 100644 torch_utils/__init__.py create mode 100644 torch_utils/custom_ops.py create mode 100644 torch_utils/misc.py create mode 100644 torch_utils/ops/__init__.py create mode 100644 torch_utils/ops/bias_act.cpp create mode 100644 torch_utils/ops/bias_act.cu create mode 100644 torch_utils/ops/bias_act.h create mode 100644 torch_utils/ops/bias_act.py create mode 100644 torch_utils/ops/conv2d_gradfix.py create mode 100644 torch_utils/ops/conv2d_resample.py create mode 100644 torch_utils/ops/filtered_lrelu.cpp create mode 100644 torch_utils/ops/filtered_lrelu.cu create mode 100644 torch_utils/ops/filtered_lrelu.h create mode 100644 torch_utils/ops/filtered_lrelu.py create mode 100644 torch_utils/ops/filtered_lrelu_ns.cu create mode 100644 torch_utils/ops/filtered_lrelu_rd.cu create mode 100644 torch_utils/ops/filtered_lrelu_wr.cu create mode 100644 torch_utils/ops/fma.py create mode 100644 torch_utils/ops/grid_sample_gradfix.py create mode 100644 torch_utils/ops/upfirdn2d.cpp create mode 100644 torch_utils/ops/upfirdn2d.cu create mode 100644 torch_utils/ops/upfirdn2d.h create mode 100644 torch_utils/ops/upfirdn2d.py create mode 100644 torch_utils/persistence.py create mode 100644 torch_utils/training_stats.py create mode 100644 workflow.png diff --git a/__init__.py b/__init__.py new file mode 100644 index 0000000..50dcb81 --- /dev/null +++ b/__init__.py @@ -0,0 +1,10 @@ +# import os +# import sys + +# repo_dir = os.path.dirname(os.path.realpath(__file__)) +# sys.path.append(os.path.join(repo_dir, "dnnlib")) +# sys.path.append(os.path.join(repo_dir, "torch_utils")) + +from .nodes import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS + +__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS'] \ No newline at end of file diff --git a/dnnlib/__init__.py b/dnnlib/__init__.py new file mode 100644 index 0000000..e7423bf --- /dev/null +++ b/dnnlib/__init__.py @@ -0,0 +1,9 @@ +# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +from .util import EasyDict, make_cache_dir_path diff --git a/dnnlib/util.py b/dnnlib/util.py new file mode 100644 index 0000000..6bbdf3b --- /dev/null +++ b/dnnlib/util.py @@ -0,0 +1,491 @@ +# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +"""Miscellaneous utility classes and functions.""" + +import ctypes +import fnmatch +import importlib +import inspect +import numpy as np +import os +import shutil +import sys +import types +import io +import pickle +import re +import requests +import html +import hashlib +import glob +import tempfile +import urllib +import urllib.request +import uuid + +from distutils.util import strtobool +from typing import Any, List, Tuple, Union + + +# Util classes +# ------------------------------------------------------------------------------------------ + + +class EasyDict(dict): + """Convenience class that behaves like a dict but allows access with the attribute syntax.""" + + def __getattr__(self, name: str) -> Any: + try: + return self[name] + except KeyError: + raise AttributeError(name) + + def __setattr__(self, name: str, value: Any) -> None: + self[name] = value + + def __delattr__(self, name: str) -> None: + del self[name] + + +class Logger(object): + """Redirect stderr to stdout, optionally print stdout to a file, and optionally force flushing on both stdout and the file.""" + + def __init__(self, file_name: str = None, file_mode: str = "w", should_flush: bool = True): + self.file = None + + if file_name is not None: + self.file = open(file_name, file_mode) + + self.should_flush = should_flush + self.stdout = sys.stdout + self.stderr = sys.stderr + + sys.stdout = self + sys.stderr = self + + def __enter__(self) -> "Logger": + return self + + def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None: + self.close() + + def write(self, text: Union[str, bytes]) -> None: + """Write text to stdout (and a file) and optionally flush.""" + if isinstance(text, bytes): + text = text.decode() + if len(text) == 0: # workaround for a bug in VSCode debugger: sys.stdout.write(''); sys.stdout.flush() => crash + return + + if self.file is not None: + self.file.write(text) + + self.stdout.write(text) + + if self.should_flush: + self.flush() + + def flush(self) -> None: + """Flush written text to both stdout and a file, if open.""" + if self.file is not None: + self.file.flush() + + self.stdout.flush() + + def close(self) -> None: + """Flush, close possible files, and remove stdout/stderr mirroring.""" + self.flush() + + # if using multiple loggers, prevent closing in wrong order + if sys.stdout is self: + sys.stdout = self.stdout + if sys.stderr is self: + sys.stderr = self.stderr + + if self.file is not None: + self.file.close() + self.file = None + + +# Cache directories +# ------------------------------------------------------------------------------------------ + +_dnnlib_cache_dir = None + +def set_cache_dir(path: str) -> None: + global _dnnlib_cache_dir + _dnnlib_cache_dir = path + +def make_cache_dir_path(*paths: str) -> str: + if _dnnlib_cache_dir is not None: + return os.path.join(_dnnlib_cache_dir, *paths) + if 'DNNLIB_CACHE_DIR' in os.environ: + return os.path.join(os.environ['DNNLIB_CACHE_DIR'], *paths) + if 'HOME' in os.environ: + return os.path.join(os.environ['HOME'], '.cache', 'dnnlib', *paths) + if 'USERPROFILE' in os.environ: + return os.path.join(os.environ['USERPROFILE'], '.cache', 'dnnlib', *paths) + return os.path.join(tempfile.gettempdir(), '.cache', 'dnnlib', *paths) + +# Small util functions +# ------------------------------------------------------------------------------------------ + + +def format_time(seconds: Union[int, float]) -> str: + """Convert the seconds to human readable string with days, hours, minutes and seconds.""" + s = int(np.rint(seconds)) + + if s < 60: + return "{0}s".format(s) + elif s < 60 * 60: + return "{0}m {1:02}s".format(s // 60, s % 60) + elif s < 24 * 60 * 60: + return "{0}h {1:02}m {2:02}s".format(s // (60 * 60), (s // 60) % 60, s % 60) + else: + return "{0}d {1:02}h {2:02}m".format(s // (24 * 60 * 60), (s // (60 * 60)) % 24, (s // 60) % 60) + + +def format_time_brief(seconds: Union[int, float]) -> str: + """Convert the seconds to human readable string with days, hours, minutes and seconds.""" + s = int(np.rint(seconds)) + + if s < 60: + return "{0}s".format(s) + elif s < 60 * 60: + return "{0}m {1:02}s".format(s // 60, s % 60) + elif s < 24 * 60 * 60: + return "{0}h {1:02}m".format(s // (60 * 60), (s // 60) % 60) + else: + return "{0}d {1:02}h".format(s // (24 * 60 * 60), (s // (60 * 60)) % 24) + + +def ask_yes_no(question: str) -> bool: + """Ask the user the question until the user inputs a valid answer.""" + while True: + try: + print("{0} [y/n]".format(question)) + return strtobool(input().lower()) + except ValueError: + pass + + +def tuple_product(t: Tuple) -> Any: + """Calculate the product of the tuple elements.""" + result = 1 + + for v in t: + result *= v + + return result + + +_str_to_ctype = { + "uint8": ctypes.c_ubyte, + "uint16": ctypes.c_uint16, + "uint32": ctypes.c_uint32, + "uint64": ctypes.c_uint64, + "int8": ctypes.c_byte, + "int16": ctypes.c_int16, + "int32": ctypes.c_int32, + "int64": ctypes.c_int64, + "float32": ctypes.c_float, + "float64": ctypes.c_double +} + + +def get_dtype_and_ctype(type_obj: Any) -> Tuple[np.dtype, Any]: + """Given a type name string (or an object having a __name__ attribute), return matching Numpy and ctypes types that have the same size in bytes.""" + type_str = None + + if isinstance(type_obj, str): + type_str = type_obj + elif hasattr(type_obj, "__name__"): + type_str = type_obj.__name__ + elif hasattr(type_obj, "name"): + type_str = type_obj.name + else: + raise RuntimeError("Cannot infer type name from input") + + assert type_str in _str_to_ctype.keys() + + my_dtype = np.dtype(type_str) + my_ctype = _str_to_ctype[type_str] + + assert my_dtype.itemsize == ctypes.sizeof(my_ctype) + + return my_dtype, my_ctype + + +def is_pickleable(obj: Any) -> bool: + try: + with io.BytesIO() as stream: + pickle.dump(obj, stream) + return True + except: + return False + + +# Functionality to import modules/objects by name, and call functions by name +# ------------------------------------------------------------------------------------------ + +def get_module_from_obj_name(obj_name: str) -> Tuple[types.ModuleType, str]: + """Searches for the underlying module behind the name to some python object. + Returns the module and the object name (original name with module part removed).""" + + # allow convenience shorthands, substitute them by full names + obj_name = re.sub("^np.", "numpy.", obj_name) + obj_name = re.sub("^tf.", "tensorflow.", obj_name) + + # list alternatives for (module_name, local_obj_name) + parts = obj_name.split(".") + name_pairs = [(".".join(parts[:i]), ".".join(parts[i:])) for i in range(len(parts), 0, -1)] + + # try each alternative in turn + for module_name, local_obj_name in name_pairs: + try: + module = importlib.import_module(module_name) # may raise ImportError + get_obj_from_module(module, local_obj_name) # may raise AttributeError + return module, local_obj_name + except: + pass + + # maybe some of the modules themselves contain errors? + for module_name, _local_obj_name in name_pairs: + try: + importlib.import_module(module_name) # may raise ImportError + except ImportError: + if not str(sys.exc_info()[1]).startswith("No module named '" + module_name + "'"): + raise + + # maybe the requested attribute is missing? + for module_name, local_obj_name in name_pairs: + try: + module = importlib.import_module(module_name) # may raise ImportError + get_obj_from_module(module, local_obj_name) # may raise AttributeError + except ImportError: + pass + + # we are out of luck, but we have no idea why + raise ImportError(obj_name) + + +def get_obj_from_module(module: types.ModuleType, obj_name: str) -> Any: + """Traverses the object name and returns the last (rightmost) python object.""" + if obj_name == '': + return module + obj = module + for part in obj_name.split("."): + obj = getattr(obj, part) + return obj + + +def get_obj_by_name(name: str) -> Any: + """Finds the python object with the given name.""" + module, obj_name = get_module_from_obj_name(name) + return get_obj_from_module(module, obj_name) + + +def call_func_by_name(*args, func_name: str = None, **kwargs) -> Any: + """Finds the python object with the given name and calls it as a function.""" + assert func_name is not None + func_obj = get_obj_by_name(func_name) + assert callable(func_obj) + return func_obj(*args, **kwargs) + + +def construct_class_by_name(*args, class_name: str = None, **kwargs) -> Any: + """Finds the python class with the given name and constructs it with the given arguments.""" + return call_func_by_name(*args, func_name=class_name, **kwargs) + + +def get_module_dir_by_obj_name(obj_name: str) -> str: + """Get the directory path of the module containing the given object name.""" + module, _ = get_module_from_obj_name(obj_name) + return os.path.dirname(inspect.getfile(module)) + + +def is_top_level_function(obj: Any) -> bool: + """Determine whether the given object is a top-level function, i.e., defined at module scope using 'def'.""" + return callable(obj) and obj.__name__ in sys.modules[obj.__module__].__dict__ + + +def get_top_level_function_name(obj: Any) -> str: + """Return the fully-qualified name of a top-level function.""" + assert is_top_level_function(obj) + module = obj.__module__ + if module == '__main__': + module = os.path.splitext(os.path.basename(sys.modules[module].__file__))[0] + return module + "." + obj.__name__ + + +# File system helpers +# ------------------------------------------------------------------------------------------ + +def list_dir_recursively_with_ignore(dir_path: str, ignores: List[str] = None, add_base_to_relative: bool = False) -> List[Tuple[str, str]]: + """List all files recursively in a given directory while ignoring given file and directory names. + Returns list of tuples containing both absolute and relative paths.""" + assert os.path.isdir(dir_path) + base_name = os.path.basename(os.path.normpath(dir_path)) + + if ignores is None: + ignores = [] + + result = [] + + for root, dirs, files in os.walk(dir_path, topdown=True): + for ignore_ in ignores: + dirs_to_remove = [d for d in dirs if fnmatch.fnmatch(d, ignore_)] + + # dirs need to be edited in-place + for d in dirs_to_remove: + dirs.remove(d) + + files = [f for f in files if not fnmatch.fnmatch(f, ignore_)] + + absolute_paths = [os.path.join(root, f) for f in files] + relative_paths = [os.path.relpath(p, dir_path) for p in absolute_paths] + + if add_base_to_relative: + relative_paths = [os.path.join(base_name, p) for p in relative_paths] + + assert len(absolute_paths) == len(relative_paths) + result += zip(absolute_paths, relative_paths) + + return result + + +def copy_files_and_create_dirs(files: List[Tuple[str, str]]) -> None: + """Takes in a list of tuples of (src, dst) paths and copies files. + Will create all necessary directories.""" + for file in files: + target_dir_name = os.path.dirname(file[1]) + + # will create all intermediate-level directories + if not os.path.exists(target_dir_name): + os.makedirs(target_dir_name) + + shutil.copyfile(file[0], file[1]) + + +# URL helpers +# ------------------------------------------------------------------------------------------ + +def is_url(obj: Any, allow_file_urls: bool = False) -> bool: + """Determine whether the given object is a valid URL string.""" + if not isinstance(obj, str) or not "://" in obj: + return False + if allow_file_urls and obj.startswith('file://'): + return True + try: + res = requests.compat.urlparse(obj) + if not res.scheme or not res.netloc or not "." in res.netloc: + return False + res = requests.compat.urlparse(requests.compat.urljoin(obj, "/")) + if not res.scheme or not res.netloc or not "." in res.netloc: + return False + except: + return False + return True + + +def open_url(url: str, cache_dir: str = None, num_attempts: int = 10, verbose: bool = True, return_filename: bool = False, cache: bool = True) -> Any: + """Download the given URL and return a binary-mode file object to access the data.""" + assert num_attempts >= 1 + assert not (return_filename and (not cache)) + + # Doesn't look like an URL scheme so interpret it as a local filename. + if not re.match('^[a-z]+://', url): + return url if return_filename else open(url, "rb") + + # Handle file URLs. This code handles unusual file:// patterns that + # arise on Windows: + # + # file:///c:/foo.txt + # + # which would translate to a local '/c:/foo.txt' filename that's + # invalid. Drop the forward slash for such pathnames. + # + # If you touch this code path, you should test it on both Linux and + # Windows. + # + # Some internet resources suggest using urllib.request.url2pathname() but + # but that converts forward slashes to backslashes and this causes + # its own set of problems. + if url.startswith('file://'): + filename = urllib.parse.urlparse(url).path + if re.match(r'^/[a-zA-Z]:', filename): + filename = filename[1:] + return filename if return_filename else open(filename, "rb") + + assert is_url(url) + + # Lookup from cache. + if cache_dir is None: + cache_dir = make_cache_dir_path('downloads') + + url_md5 = hashlib.md5(url.encode("utf-8")).hexdigest() + if cache: + cache_files = glob.glob(os.path.join(cache_dir, url_md5 + "_*")) + if len(cache_files) == 1: + filename = cache_files[0] + return filename if return_filename else open(filename, "rb") + + # Download. + url_name = None + url_data = None + with requests.Session() as session: + if verbose: + print("Downloading %s ..." % url, end="", flush=True) + for attempts_left in reversed(range(num_attempts)): + try: + with session.get(url) as res: + res.raise_for_status() + if len(res.content) == 0: + raise IOError("No data received") + + if len(res.content) < 8192: + content_str = res.content.decode("utf-8") + if "download_warning" in res.headers.get("Set-Cookie", ""): + links = [html.unescape(link) for link in content_str.split('"') if "export=download" in link] + if len(links) == 1: + url = requests.compat.urljoin(url, links[0]) + raise IOError("Google Drive virus checker nag") + if "Google Drive - Quota exceeded" in content_str: + raise IOError("Google Drive download quota exceeded -- please try again later") + + match = re.search(r'filename="([^"]*)"', res.headers.get("Content-Disposition", "")) + url_name = match[1] if match else url + url_data = res.content + if verbose: + print(" done") + break + except KeyboardInterrupt: + raise + except: + if not attempts_left: + if verbose: + print(" failed") + raise + if verbose: + print(".", end="", flush=True) + + # Save to cache. + if cache: + safe_name = re.sub(r"[^0-9a-zA-Z-._]", "_", url_name) + cache_file = os.path.join(cache_dir, url_md5 + "_" + safe_name) + temp_file = os.path.join(cache_dir, "tmp_" + uuid.uuid4().hex + "_" + url_md5 + "_" + safe_name) + os.makedirs(cache_dir, exist_ok=True) + with open(temp_file, "wb") as f: + f.write(url_data) + os.replace(temp_file, cache_file) # atomic + if return_filename: + return cache_file + + # Return data as file object. + assert not return_filename + return io.BytesIO(url_data) diff --git a/nodes.py b/nodes.py new file mode 100644 index 0000000..99ff353 --- /dev/null +++ b/nodes.py @@ -0,0 +1,105 @@ +import os +import sys +# import subprocess +import numpy as np +import pickle +import torch + +# repo_dir = os.path.dirname(os.path.realpath(__file__)) +# print(repo_dir) +# sys.path.append(os.path.join(repo_dir, "dnnlib")) +# sys.path.append(os.path.join(repo_dir, "torch_utils")) +# dnnlib_path = os.path.join(repo_dir, "dnnlib") +# torch_utils_path = os.path.join(repo_dir, "torch_utils") +# subprocess.run([sys.executable, "-m", "pip", "install", dnnlib_path, "-t", dnnlib_path]) +# subprocess.run([sys.executable, "-m", "pip", "install", torch_utils_path, "-t", torch_utils_path]) + +from . import dnnlib +from . import torch_utils +# import dnnlib +# import torch_utils +sys.modules["dnnlib"] = dnnlib +sys.modules["torch_utils"] = torch_utils + +import folder_paths + +# set the models directory +if "stylegan" not in folder_paths.folder_names_and_paths: + current_paths = [os.path.join(folder_paths.models_dir, "stylegan")] +else: + current_paths, _ = folder_paths.folder_names_and_paths["stylegan"] +folder_paths.folder_names_and_paths["stylegan"] = (current_paths, folder_paths.supported_pt_extensions) + +class LoadStyleGAN: + @classmethod + def INPUT_TYPES(s): + return { + "required": { + "stylegan_file": (folder_paths.get_filename_list("stylegan"), ), + }, + } + + RETURN_TYPES = ("STYLEGAN",) + FUNCTION = "load_stylegan" + CATEGORY = "StyleGAN" + + def load_stylegan(self, stylegan_file): + with open(folder_paths.get_full_path("stylegan", stylegan_file), 'rb') as f: + G = pickle.load(f)['G_ema'].cuda() + return (G,) + +class GenerateStyleGANLatent: + @classmethod + def INPUT_TYPES(s): + return { + "required": { + "stylegan_model": ("STYLEGAN", ), + "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}), + }, + } + + RETURN_TYPES = ("STYLEGAN_LATENT",) + FUNCTION = "generate_latent" + CATEGORY = "StyleGAN" + + def generate_latent(self, stylegan_model, seed): + torch.manual_seed(seed) + z = torch.randn([1, stylegan_model.z_dim]).cuda() + return (z, ) + +class StyleGANSampler: + @classmethod + def INPUT_TYPES(s): + return { + "required": { + "stylegan_model": ("STYLEGAN", ), + "stylegan_latent": ("STYLEGAN_LATENT", ), + "class_label": ("INT", {"default": -1, "min": -1}), + }, + } + + RETURN_TYPES = ("IMAGE",) + FUNCTION = "generate_image" + CATEGORY = "StyleGAN" + + def generate_image(self, stylegan_model, stylegan_latent, class_label): + if class_label < 0: + class_label = None + + img = stylegan_model(stylegan_latent, class_label) + img = torch.permute(img, (0, 2, 3, 1)) # BCHW -> BHWC + img = torch.clip(img / 2 + 0.5, 0, 1) # [-1, 1] -> [0, 1] + + return (img, ) + +NODE_CLASS_MAPPINGS = { + "LoadStyleGAN": LoadStyleGAN, + "GenerateStyleGANLatent": GenerateStyleGANLatent, + "StyleGANSampler": StyleGANSampler, +} + +NODE_DISPLAY_NAME_MAPPINGS = { + "LoadStyleGAN": "Load StyleGAN Model", + "GenerateStyleGANLatent": "Generate StyleGAN Latent", + "StyleGANSampler": "StyleGAN Sampler", +} \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..d11e3ca --- /dev/null +++ b/requirements.txt @@ -0,0 +1,3 @@ +numpy +pickle +ninja \ No newline at end of file diff --git a/torch_utils/__init__.py b/torch_utils/__init__.py new file mode 100644 index 0000000..939e7c6 --- /dev/null +++ b/torch_utils/__init__.py @@ -0,0 +1,9 @@ +# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +# empty diff --git a/torch_utils/custom_ops.py b/torch_utils/custom_ops.py new file mode 100644 index 0000000..439e445 --- /dev/null +++ b/torch_utils/custom_ops.py @@ -0,0 +1,157 @@ +# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +import glob +import hashlib +import importlib +import os +import re +import shutil +import uuid + +import torch +import torch.utils.cpp_extension +from torch.utils.file_baton import FileBaton + +#---------------------------------------------------------------------------- +# Global options. + +verbosity = 'brief' # Verbosity level: 'none', 'brief', 'full' + +#---------------------------------------------------------------------------- +# Internal helper funcs. + +def _find_compiler_bindir(): + patterns = [ + 'C:/Program Files*/Microsoft Visual Studio/*/Professional/VC/Tools/MSVC/*/bin/Hostx64/x64', + 'C:/Program Files*/Microsoft Visual Studio/*/BuildTools/VC/Tools/MSVC/*/bin/Hostx64/x64', + 'C:/Program Files*/Microsoft Visual Studio/*/Community/VC/Tools/MSVC/*/bin/Hostx64/x64', + 'C:/Program Files*/Microsoft Visual Studio */vc/bin', + ] + for pattern in patterns: + matches = sorted(glob.glob(pattern)) + if len(matches): + return matches[-1] + return None + +#---------------------------------------------------------------------------- + +def _get_mangled_gpu_name(): + name = torch.cuda.get_device_name().lower() + out = [] + for c in name: + if re.match('[a-z0-9_-]+', c): + out.append(c) + else: + out.append('-') + return ''.join(out) + +#---------------------------------------------------------------------------- +# Main entry point for compiling and loading C++/CUDA plugins. + +_cached_plugins = dict() + +def get_plugin(module_name, sources, headers=None, source_dir=None, **build_kwargs): + assert verbosity in ['none', 'brief', 'full'] + if headers is None: + headers = [] + if source_dir is not None: + sources = [os.path.join(source_dir, fname) for fname in sources] + headers = [os.path.join(source_dir, fname) for fname in headers] + + # Already cached? + if module_name in _cached_plugins: + return _cached_plugins[module_name] + + # Print status. + if verbosity == 'full': + print(f'Setting up PyTorch plugin "{module_name}"...') + elif verbosity == 'brief': + print(f'Setting up PyTorch plugin "{module_name}"... ', end='', flush=True) + verbose_build = (verbosity == 'full') + + # Compile and load. + try: # pylint: disable=too-many-nested-blocks + # Make sure we can find the necessary compiler binaries. + if os.name == 'nt' and os.system("where cl.exe >nul 2>nul") != 0: + compiler_bindir = _find_compiler_bindir() + if compiler_bindir is None: + raise RuntimeError(f'Could not find MSVC/GCC/CLANG installation on this computer. Check _find_compiler_bindir() in "{__file__}".') + os.environ['PATH'] += ';' + compiler_bindir + + # Some containers set TORCH_CUDA_ARCH_LIST to a list that can either + # break the build or unnecessarily restrict what's available to nvcc. + # Unset it to let nvcc decide based on what's available on the + # machine. + os.environ['TORCH_CUDA_ARCH_LIST'] = '' + + # Incremental build md5sum trickery. Copies all the input source files + # into a cached build directory under a combined md5 digest of the input + # source files. Copying is done only if the combined digest has changed. + # This keeps input file timestamps and filenames the same as in previous + # extension builds, allowing for fast incremental rebuilds. + # + # This optimization is done only in case all the source files reside in + # a single directory (just for simplicity) and if the TORCH_EXTENSIONS_DIR + # environment variable is set (we take this as a signal that the user + # actually cares about this.) + # + # EDIT: We now do it regardless of TORCH_EXTENSIOS_DIR, in order to work + # around the *.cu dependency bug in ninja config. + # + all_source_files = sorted(sources + headers) + all_source_dirs = set(os.path.dirname(fname) for fname in all_source_files) + if len(all_source_dirs) == 1: # and ('TORCH_EXTENSIONS_DIR' in os.environ): + + # Compute combined hash digest for all source files. + hash_md5 = hashlib.md5() + for src in all_source_files: + with open(src, 'rb') as f: + hash_md5.update(f.read()) + + # Select cached build directory name. + source_digest = hash_md5.hexdigest() + build_top_dir = torch.utils.cpp_extension._get_build_directory(module_name, verbose=verbose_build) # pylint: disable=protected-access + cached_build_dir = os.path.join(build_top_dir, f'{source_digest}-{_get_mangled_gpu_name()}') + + if not os.path.isdir(cached_build_dir): + tmpdir = f'{build_top_dir}/srctmp-{uuid.uuid4().hex}' + os.makedirs(tmpdir) + for src in all_source_files: + shutil.copyfile(src, os.path.join(tmpdir, os.path.basename(src))) + try: + os.replace(tmpdir, cached_build_dir) # atomic + except OSError: + # source directory already exists, delete tmpdir and its contents. + shutil.rmtree(tmpdir) + if not os.path.isdir(cached_build_dir): raise + + # Compile. + cached_sources = [os.path.join(cached_build_dir, os.path.basename(fname)) for fname in sources] + torch.utils.cpp_extension.load(name=module_name, build_directory=cached_build_dir, + verbose=verbose_build, sources=cached_sources, **build_kwargs) + else: + torch.utils.cpp_extension.load(name=module_name, verbose=verbose_build, sources=sources, **build_kwargs) + + # Load. + module = importlib.import_module(module_name) + + except: + if verbosity == 'brief': + print('Failed!') + raise + + # Print status and add to cache dict. + if verbosity == 'full': + print(f'Done setting up PyTorch plugin "{module_name}".') + elif verbosity == 'brief': + print('Done.') + _cached_plugins[module_name] = module + return module + +#---------------------------------------------------------------------------- diff --git a/torch_utils/misc.py b/torch_utils/misc.py new file mode 100644 index 0000000..335397d --- /dev/null +++ b/torch_utils/misc.py @@ -0,0 +1,266 @@ +# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +import re +import contextlib +import numpy as np +import torch +import warnings +import dnnlib + +#---------------------------------------------------------------------------- +# Cached construction of constant tensors. Avoids CPU=>GPU copy when the +# same constant is used multiple times. + +_constant_cache = dict() + +def constant(value, shape=None, dtype=None, device=None, memory_format=None): + value = np.asarray(value) + if shape is not None: + shape = tuple(shape) + if dtype is None: + dtype = torch.get_default_dtype() + if device is None: + device = torch.device('cpu') + if memory_format is None: + memory_format = torch.contiguous_format + + key = (value.shape, value.dtype, value.tobytes(), shape, dtype, device, memory_format) + tensor = _constant_cache.get(key, None) + if tensor is None: + tensor = torch.as_tensor(value.copy(), dtype=dtype, device=device) + if shape is not None: + tensor, _ = torch.broadcast_tensors(tensor, torch.empty(shape)) + tensor = tensor.contiguous(memory_format=memory_format) + _constant_cache[key] = tensor + return tensor + +#---------------------------------------------------------------------------- +# Replace NaN/Inf with specified numerical values. + +try: + nan_to_num = torch.nan_to_num # 1.8.0a0 +except AttributeError: + def nan_to_num(input, nan=0.0, posinf=None, neginf=None, *, out=None): # pylint: disable=redefined-builtin + assert isinstance(input, torch.Tensor) + if posinf is None: + posinf = torch.finfo(input.dtype).max + if neginf is None: + neginf = torch.finfo(input.dtype).min + assert nan == 0 + return torch.clamp(input.unsqueeze(0).nansum(0), min=neginf, max=posinf, out=out) + +#---------------------------------------------------------------------------- +# Symbolic assert. + +try: + symbolic_assert = torch._assert # 1.8.0a0 # pylint: disable=protected-access +except AttributeError: + symbolic_assert = torch.Assert # 1.7.0 + +#---------------------------------------------------------------------------- +# Context manager to temporarily suppress known warnings in torch.jit.trace(). +# Note: Cannot use catch_warnings because of https://bugs.python.org/issue29672 + +@contextlib.contextmanager +def suppress_tracer_warnings(): + flt = ('ignore', None, torch.jit.TracerWarning, None, 0) + warnings.filters.insert(0, flt) + yield + warnings.filters.remove(flt) + +#---------------------------------------------------------------------------- +# Assert that the shape of a tensor matches the given list of integers. +# None indicates that the size of a dimension is allowed to vary. +# Performs symbolic assertion when used in torch.jit.trace(). + +def assert_shape(tensor, ref_shape): + if tensor.ndim != len(ref_shape): + raise AssertionError(f'Wrong number of dimensions: got {tensor.ndim}, expected {len(ref_shape)}') + for idx, (size, ref_size) in enumerate(zip(tensor.shape, ref_shape)): + if ref_size is None: + pass + elif isinstance(ref_size, torch.Tensor): + with suppress_tracer_warnings(): # as_tensor results are registered as constants + symbolic_assert(torch.equal(torch.as_tensor(size), ref_size), f'Wrong size for dimension {idx}') + elif isinstance(size, torch.Tensor): + with suppress_tracer_warnings(): # as_tensor results are registered as constants + symbolic_assert(torch.equal(size, torch.as_tensor(ref_size)), f'Wrong size for dimension {idx}: expected {ref_size}') + elif size != ref_size: + raise AssertionError(f'Wrong size for dimension {idx}: got {size}, expected {ref_size}') + +#---------------------------------------------------------------------------- +# Function decorator that calls torch.autograd.profiler.record_function(). + +def profiled_function(fn): + def decorator(*args, **kwargs): + with torch.autograd.profiler.record_function(fn.__name__): + return fn(*args, **kwargs) + decorator.__name__ = fn.__name__ + return decorator + +#---------------------------------------------------------------------------- +# Sampler for torch.utils.data.DataLoader that loops over the dataset +# indefinitely, shuffling items as it goes. + +class InfiniteSampler(torch.utils.data.Sampler): + def __init__(self, dataset, rank=0, num_replicas=1, shuffle=True, seed=0, window_size=0.5): + assert len(dataset) > 0 + assert num_replicas > 0 + assert 0 <= rank < num_replicas + assert 0 <= window_size <= 1 + super().__init__(dataset) + self.dataset = dataset + self.rank = rank + self.num_replicas = num_replicas + self.shuffle = shuffle + self.seed = seed + self.window_size = window_size + + def __iter__(self): + order = np.arange(len(self.dataset)) + rnd = None + window = 0 + if self.shuffle: + rnd = np.random.RandomState(self.seed) + rnd.shuffle(order) + window = int(np.rint(order.size * self.window_size)) + + idx = 0 + while True: + i = idx % order.size + if idx % self.num_replicas == self.rank: + yield order[i] + if window >= 2: + j = (i - rnd.randint(window)) % order.size + order[i], order[j] = order[j], order[i] + idx += 1 + +#---------------------------------------------------------------------------- +# Utilities for operating with torch.nn.Module parameters and buffers. + +def params_and_buffers(module): + assert isinstance(module, torch.nn.Module) + return list(module.parameters()) + list(module.buffers()) + +def named_params_and_buffers(module): + assert isinstance(module, torch.nn.Module) + return list(module.named_parameters()) + list(module.named_buffers()) + +def copy_params_and_buffers(src_module, dst_module, require_all=False): + assert isinstance(src_module, torch.nn.Module) + assert isinstance(dst_module, torch.nn.Module) + src_tensors = dict(named_params_and_buffers(src_module)) + for name, tensor in named_params_and_buffers(dst_module): + assert (name in src_tensors) or (not require_all) + if name in src_tensors: + tensor.copy_(src_tensors[name].detach()).requires_grad_(tensor.requires_grad) + +#---------------------------------------------------------------------------- +# Context manager for easily enabling/disabling DistributedDataParallel +# synchronization. + +@contextlib.contextmanager +def ddp_sync(module, sync): + assert isinstance(module, torch.nn.Module) + if sync or not isinstance(module, torch.nn.parallel.DistributedDataParallel): + yield + else: + with module.no_sync(): + yield + +#---------------------------------------------------------------------------- +# Check DistributedDataParallel consistency across processes. + +def check_ddp_consistency(module, ignore_regex=None): + assert isinstance(module, torch.nn.Module) + for name, tensor in named_params_and_buffers(module): + fullname = type(module).__name__ + '.' + name + if ignore_regex is not None and re.fullmatch(ignore_regex, fullname): + continue + tensor = tensor.detach() + if tensor.is_floating_point(): + tensor = nan_to_num(tensor) + other = tensor.clone() + torch.distributed.broadcast(tensor=other, src=0) + assert (tensor == other).all(), fullname + +#---------------------------------------------------------------------------- +# Print summary table of module hierarchy. + +def print_module_summary(module, inputs, max_nesting=3, skip_redundant=True): + assert isinstance(module, torch.nn.Module) + assert not isinstance(module, torch.jit.ScriptModule) + assert isinstance(inputs, (tuple, list)) + + # Register hooks. + entries = [] + nesting = [0] + def pre_hook(_mod, _inputs): + nesting[0] += 1 + def post_hook(mod, _inputs, outputs): + nesting[0] -= 1 + if nesting[0] <= max_nesting: + outputs = list(outputs) if isinstance(outputs, (tuple, list)) else [outputs] + outputs = [t for t in outputs if isinstance(t, torch.Tensor)] + entries.append(dnnlib.EasyDict(mod=mod, outputs=outputs)) + hooks = [mod.register_forward_pre_hook(pre_hook) for mod in module.modules()] + hooks += [mod.register_forward_hook(post_hook) for mod in module.modules()] + + # Run module. + outputs = module(*inputs) + for hook in hooks: + hook.remove() + + # Identify unique outputs, parameters, and buffers. + tensors_seen = set() + for e in entries: + e.unique_params = [t for t in e.mod.parameters() if id(t) not in tensors_seen] + e.unique_buffers = [t for t in e.mod.buffers() if id(t) not in tensors_seen] + e.unique_outputs = [t for t in e.outputs if id(t) not in tensors_seen] + tensors_seen |= {id(t) for t in e.unique_params + e.unique_buffers + e.unique_outputs} + + # Filter out redundant entries. + if skip_redundant: + entries = [e for e in entries if len(e.unique_params) or len(e.unique_buffers) or len(e.unique_outputs)] + + # Construct table. + rows = [[type(module).__name__, 'Parameters', 'Buffers', 'Output shape', 'Datatype']] + rows += [['---'] * len(rows[0])] + param_total = 0 + buffer_total = 0 + submodule_names = {mod: name for name, mod in module.named_modules()} + for e in entries: + name = '' if e.mod is module else submodule_names[e.mod] + param_size = sum(t.numel() for t in e.unique_params) + buffer_size = sum(t.numel() for t in e.unique_buffers) + output_shapes = [str(list(t.shape)) for t in e.outputs] + output_dtypes = [str(t.dtype).split('.')[-1] for t in e.outputs] + rows += [[ + name + (':0' if len(e.outputs) >= 2 else ''), + str(param_size) if param_size else '-', + str(buffer_size) if buffer_size else '-', + (output_shapes + ['-'])[0], + (output_dtypes + ['-'])[0], + ]] + for idx in range(1, len(e.outputs)): + rows += [[name + f':{idx}', '-', '-', output_shapes[idx], output_dtypes[idx]]] + param_total += param_size + buffer_total += buffer_size + rows += [['---'] * len(rows[0])] + rows += [['Total', str(param_total), str(buffer_total), '-', '-']] + + # Print table. + widths = [max(len(cell) for cell in column) for column in zip(*rows)] + print() + for row in rows: + print(' '.join(cell + ' ' * (width - len(cell)) for cell, width in zip(row, widths))) + print() + return outputs + +#---------------------------------------------------------------------------- diff --git a/torch_utils/ops/__init__.py b/torch_utils/ops/__init__.py new file mode 100644 index 0000000..939e7c6 --- /dev/null +++ b/torch_utils/ops/__init__.py @@ -0,0 +1,9 @@ +# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +# empty diff --git a/torch_utils/ops/bias_act.cpp b/torch_utils/ops/bias_act.cpp new file mode 100644 index 0000000..3adaeee --- /dev/null +++ b/torch_utils/ops/bias_act.cpp @@ -0,0 +1,99 @@ +// Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + +#include +#include +#include +#include "bias_act.h" + +//------------------------------------------------------------------------ + +static bool has_same_layout(torch::Tensor x, torch::Tensor y) +{ + if (x.dim() != y.dim()) + return false; + for (int64_t i = 0; i < x.dim(); i++) + { + if (x.size(i) != y.size(i)) + return false; + if (x.size(i) >= 2 && x.stride(i) != y.stride(i)) + return false; + } + return true; +} + +//------------------------------------------------------------------------ + +static torch::Tensor bias_act(torch::Tensor x, torch::Tensor b, torch::Tensor xref, torch::Tensor yref, torch::Tensor dy, int grad, int dim, int act, float alpha, float gain, float clamp) +{ + // Validate arguments. + TORCH_CHECK(x.is_cuda(), "x must reside on CUDA device"); + TORCH_CHECK(b.numel() == 0 || (b.dtype() == x.dtype() && b.device() == x.device()), "b must have the same dtype and device as x"); + TORCH_CHECK(xref.numel() == 0 || (xref.sizes() == x.sizes() && xref.dtype() == x.dtype() && xref.device() == x.device()), "xref must have the same shape, dtype, and device as x"); + TORCH_CHECK(yref.numel() == 0 || (yref.sizes() == x.sizes() && yref.dtype() == x.dtype() && yref.device() == x.device()), "yref must have the same shape, dtype, and device as x"); + TORCH_CHECK(dy.numel() == 0 || (dy.sizes() == x.sizes() && dy.dtype() == x.dtype() && dy.device() == x.device()), "dy must have the same dtype and device as x"); + TORCH_CHECK(x.numel() <= INT_MAX, "x is too large"); + TORCH_CHECK(b.dim() == 1, "b must have rank 1"); + TORCH_CHECK(b.numel() == 0 || (dim >= 0 && dim < x.dim()), "dim is out of bounds"); + TORCH_CHECK(b.numel() == 0 || b.numel() == x.size(dim), "b has wrong number of elements"); + TORCH_CHECK(grad >= 0, "grad must be non-negative"); + + // Validate layout. + TORCH_CHECK(x.is_non_overlapping_and_dense(), "x must be non-overlapping and dense"); + TORCH_CHECK(b.is_contiguous(), "b must be contiguous"); + TORCH_CHECK(xref.numel() == 0 || has_same_layout(xref, x), "xref must have the same layout as x"); + TORCH_CHECK(yref.numel() == 0 || has_same_layout(yref, x), "yref must have the same layout as x"); + TORCH_CHECK(dy.numel() == 0 || has_same_layout(dy, x), "dy must have the same layout as x"); + + // Create output tensor. + const at::cuda::OptionalCUDAGuard device_guard(device_of(x)); + torch::Tensor y = torch::empty_like(x); + TORCH_CHECK(has_same_layout(y, x), "y must have the same layout as x"); + + // Initialize CUDA kernel parameters. + bias_act_kernel_params p; + p.x = x.data_ptr(); + p.b = (b.numel()) ? b.data_ptr() : NULL; + p.xref = (xref.numel()) ? xref.data_ptr() : NULL; + p.yref = (yref.numel()) ? yref.data_ptr() : NULL; + p.dy = (dy.numel()) ? dy.data_ptr() : NULL; + p.y = y.data_ptr(); + p.grad = grad; + p.act = act; + p.alpha = alpha; + p.gain = gain; + p.clamp = clamp; + p.sizeX = (int)x.numel(); + p.sizeB = (int)b.numel(); + p.stepB = (b.numel()) ? (int)x.stride(dim) : 1; + + // Choose CUDA kernel. + void* kernel; + AT_DISPATCH_FLOATING_TYPES_AND_HALF(x.scalar_type(), "upfirdn2d_cuda", [&] + { + kernel = choose_bias_act_kernel(p); + }); + TORCH_CHECK(kernel, "no CUDA kernel found for the specified activation func"); + + // Launch CUDA kernel. + p.loopX = 4; + int blockSize = 4 * 32; + int gridSize = (p.sizeX - 1) / (p.loopX * blockSize) + 1; + void* args[] = {&p}; + AT_CUDA_CHECK(cudaLaunchKernel(kernel, gridSize, blockSize, args, 0, at::cuda::getCurrentCUDAStream())); + return y; +} + +//------------------------------------------------------------------------ + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) +{ + m.def("bias_act", &bias_act); +} + +//------------------------------------------------------------------------ diff --git a/torch_utils/ops/bias_act.cu b/torch_utils/ops/bias_act.cu new file mode 100644 index 0000000..ed1d16f --- /dev/null +++ b/torch_utils/ops/bias_act.cu @@ -0,0 +1,173 @@ +// Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + +#include +#include "bias_act.h" + +//------------------------------------------------------------------------ +// Helpers. + +template struct InternalType; +template <> struct InternalType { typedef double scalar_t; }; +template <> struct InternalType { typedef float scalar_t; }; +template <> struct InternalType { typedef float scalar_t; }; + +//------------------------------------------------------------------------ +// CUDA kernel. + +template +__global__ void bias_act_kernel(bias_act_kernel_params p) +{ + typedef typename InternalType::scalar_t scalar_t; + int G = p.grad; + scalar_t alpha = (scalar_t)p.alpha; + scalar_t gain = (scalar_t)p.gain; + scalar_t clamp = (scalar_t)p.clamp; + scalar_t one = (scalar_t)1; + scalar_t two = (scalar_t)2; + scalar_t expRange = (scalar_t)80; + scalar_t halfExpRange = (scalar_t)40; + scalar_t seluScale = (scalar_t)1.0507009873554804934193349852946; + scalar_t seluAlpha = (scalar_t)1.6732632423543772848170429916717; + + // Loop over elements. + int xi = blockIdx.x * p.loopX * blockDim.x + threadIdx.x; + for (int loopIdx = 0; loopIdx < p.loopX && xi < p.sizeX; loopIdx++, xi += blockDim.x) + { + // Load. + scalar_t x = (scalar_t)((const T*)p.x)[xi]; + scalar_t b = (p.b) ? (scalar_t)((const T*)p.b)[(xi / p.stepB) % p.sizeB] : 0; + scalar_t xref = (p.xref) ? (scalar_t)((const T*)p.xref)[xi] : 0; + scalar_t yref = (p.yref) ? (scalar_t)((const T*)p.yref)[xi] : 0; + scalar_t dy = (p.dy) ? (scalar_t)((const T*)p.dy)[xi] : one; + scalar_t yy = (gain != 0) ? yref / gain : 0; + scalar_t y = 0; + + // Apply bias. + ((G == 0) ? x : xref) += b; + + // linear + if (A == 1) + { + if (G == 0) y = x; + if (G == 1) y = x; + } + + // relu + if (A == 2) + { + if (G == 0) y = (x > 0) ? x : 0; + if (G == 1) y = (yy > 0) ? x : 0; + } + + // lrelu + if (A == 3) + { + if (G == 0) y = (x > 0) ? x : x * alpha; + if (G == 1) y = (yy > 0) ? x : x * alpha; + } + + // tanh + if (A == 4) + { + if (G == 0) { scalar_t c = exp(x); scalar_t d = one / c; y = (x < -expRange) ? -one : (x > expRange) ? one : (c - d) / (c + d); } + if (G == 1) y = x * (one - yy * yy); + if (G == 2) y = x * (one - yy * yy) * (-two * yy); + } + + // sigmoid + if (A == 5) + { + if (G == 0) y = (x < -expRange) ? 0 : one / (exp(-x) + one); + if (G == 1) y = x * yy * (one - yy); + if (G == 2) y = x * yy * (one - yy) * (one - two * yy); + } + + // elu + if (A == 6) + { + if (G == 0) y = (x >= 0) ? x : exp(x) - one; + if (G == 1) y = (yy >= 0) ? x : x * (yy + one); + if (G == 2) y = (yy >= 0) ? 0 : x * (yy + one); + } + + // selu + if (A == 7) + { + if (G == 0) y = (x >= 0) ? seluScale * x : (seluScale * seluAlpha) * (exp(x) - one); + if (G == 1) y = (yy >= 0) ? x * seluScale : x * (yy + seluScale * seluAlpha); + if (G == 2) y = (yy >= 0) ? 0 : x * (yy + seluScale * seluAlpha); + } + + // softplus + if (A == 8) + { + if (G == 0) y = (x > expRange) ? x : log(exp(x) + one); + if (G == 1) y = x * (one - exp(-yy)); + if (G == 2) { scalar_t c = exp(-yy); y = x * c * (one - c); } + } + + // swish + if (A == 9) + { + if (G == 0) + y = (x < -expRange) ? 0 : x / (exp(-x) + one); + else + { + scalar_t c = exp(xref); + scalar_t d = c + one; + if (G == 1) + y = (xref > halfExpRange) ? x : x * c * (xref + d) / (d * d); + else + y = (xref > halfExpRange) ? 0 : x * c * (xref * (two - d) + two * d) / (d * d * d); + yref = (xref < -expRange) ? 0 : xref / (exp(-xref) + one) * gain; + } + } + + // Apply gain. + y *= gain * dy; + + // Clamp. + if (clamp >= 0) + { + if (G == 0) + y = (y > -clamp & y < clamp) ? y : (y >= 0) ? clamp : -clamp; + else + y = (yref > -clamp & yref < clamp) ? y : 0; + } + + // Store. + ((T*)p.y)[xi] = (T)y; + } +} + +//------------------------------------------------------------------------ +// CUDA kernel selection. + +template void* choose_bias_act_kernel(const bias_act_kernel_params& p) +{ + if (p.act == 1) return (void*)bias_act_kernel; + if (p.act == 2) return (void*)bias_act_kernel; + if (p.act == 3) return (void*)bias_act_kernel; + if (p.act == 4) return (void*)bias_act_kernel; + if (p.act == 5) return (void*)bias_act_kernel; + if (p.act == 6) return (void*)bias_act_kernel; + if (p.act == 7) return (void*)bias_act_kernel; + if (p.act == 8) return (void*)bias_act_kernel; + if (p.act == 9) return (void*)bias_act_kernel; + return NULL; +} + +//------------------------------------------------------------------------ +// Template specializations. + +template void* choose_bias_act_kernel (const bias_act_kernel_params& p); +template void* choose_bias_act_kernel (const bias_act_kernel_params& p); +template void* choose_bias_act_kernel (const bias_act_kernel_params& p); + +//------------------------------------------------------------------------ diff --git a/torch_utils/ops/bias_act.h b/torch_utils/ops/bias_act.h new file mode 100644 index 0000000..60b81c6 --- /dev/null +++ b/torch_utils/ops/bias_act.h @@ -0,0 +1,38 @@ +// Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + +//------------------------------------------------------------------------ +// CUDA kernel parameters. + +struct bias_act_kernel_params +{ + const void* x; // [sizeX] + const void* b; // [sizeB] or NULL + const void* xref; // [sizeX] or NULL + const void* yref; // [sizeX] or NULL + const void* dy; // [sizeX] or NULL + void* y; // [sizeX] + + int grad; + int act; + float alpha; + float gain; + float clamp; + + int sizeX; + int sizeB; + int stepB; + int loopX; +}; + +//------------------------------------------------------------------------ +// CUDA kernel selection. + +template void* choose_bias_act_kernel(const bias_act_kernel_params& p); + +//------------------------------------------------------------------------ diff --git a/torch_utils/ops/bias_act.py b/torch_utils/ops/bias_act.py new file mode 100644 index 0000000..b2b53d7 --- /dev/null +++ b/torch_utils/ops/bias_act.py @@ -0,0 +1,209 @@ +# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +"""Custom PyTorch ops for efficient bias and activation.""" + +import os +import numpy as np +import torch +import dnnlib + +from .. import custom_ops +from .. import misc + +#---------------------------------------------------------------------------- + +activation_funcs = { + 'linear': dnnlib.EasyDict(func=lambda x, **_: x, def_alpha=0, def_gain=1, cuda_idx=1, ref='', has_2nd_grad=False), + 'relu': dnnlib.EasyDict(func=lambda x, **_: torch.nn.functional.relu(x), def_alpha=0, def_gain=np.sqrt(2), cuda_idx=2, ref='y', has_2nd_grad=False), + 'lrelu': dnnlib.EasyDict(func=lambda x, alpha, **_: torch.nn.functional.leaky_relu(x, alpha), def_alpha=0.2, def_gain=np.sqrt(2), cuda_idx=3, ref='y', has_2nd_grad=False), + 'tanh': dnnlib.EasyDict(func=lambda x, **_: torch.tanh(x), def_alpha=0, def_gain=1, cuda_idx=4, ref='y', has_2nd_grad=True), + 'sigmoid': dnnlib.EasyDict(func=lambda x, **_: torch.sigmoid(x), def_alpha=0, def_gain=1, cuda_idx=5, ref='y', has_2nd_grad=True), + 'elu': dnnlib.EasyDict(func=lambda x, **_: torch.nn.functional.elu(x), def_alpha=0, def_gain=1, cuda_idx=6, ref='y', has_2nd_grad=True), + 'selu': dnnlib.EasyDict(func=lambda x, **_: torch.nn.functional.selu(x), def_alpha=0, def_gain=1, cuda_idx=7, ref='y', has_2nd_grad=True), + 'softplus': dnnlib.EasyDict(func=lambda x, **_: torch.nn.functional.softplus(x), def_alpha=0, def_gain=1, cuda_idx=8, ref='y', has_2nd_grad=True), + 'swish': dnnlib.EasyDict(func=lambda x, **_: torch.sigmoid(x) * x, def_alpha=0, def_gain=np.sqrt(2), cuda_idx=9, ref='x', has_2nd_grad=True), +} + +#---------------------------------------------------------------------------- + +_plugin = None +_null_tensor = torch.empty([0]) + +def _init(): + global _plugin + if _plugin is None: + _plugin = custom_ops.get_plugin( + module_name='bias_act_plugin', + sources=['bias_act.cpp', 'bias_act.cu'], + headers=['bias_act.h'], + source_dir=os.path.dirname(__file__), + extra_cuda_cflags=['--use_fast_math', '--allow-unsupported-compiler'], + ) + return True + +#---------------------------------------------------------------------------- + +def bias_act(x, b=None, dim=1, act='linear', alpha=None, gain=None, clamp=None, impl='cuda'): + r"""Fused bias and activation function. + + Adds bias `b` to activation tensor `x`, evaluates activation function `act`, + and scales the result by `gain`. Each of the steps is optional. In most cases, + the fused op is considerably more efficient than performing the same calculation + using standard PyTorch ops. It supports first and second order gradients, + but not third order gradients. + + Args: + x: Input activation tensor. Can be of any shape. + b: Bias vector, or `None` to disable. Must be a 1D tensor of the same type + as `x`. The shape must be known, and it must match the dimension of `x` + corresponding to `dim`. + dim: The dimension in `x` corresponding to the elements of `b`. + The value of `dim` is ignored if `b` is not specified. + act: Name of the activation function to evaluate, or `"linear"` to disable. + Can be e.g. `"relu"`, `"lrelu"`, `"tanh"`, `"sigmoid"`, `"swish"`, etc. + See `activation_funcs` for a full list. `None` is not allowed. + alpha: Shape parameter for the activation function, or `None` to use the default. + gain: Scaling factor for the output tensor, or `None` to use default. + See `activation_funcs` for the default scaling of each activation function. + If unsure, consider specifying 1. + clamp: Clamp the output values to `[-clamp, +clamp]`, or `None` to disable + the clamping (default). + impl: Name of the implementation to use. Can be `"ref"` or `"cuda"` (default). + + Returns: + Tensor of the same shape and datatype as `x`. + """ + assert isinstance(x, torch.Tensor) + assert impl in ['ref', 'cuda'] + if impl == 'cuda' and x.device.type == 'cuda' and _init(): + return _bias_act_cuda(dim=dim, act=act, alpha=alpha, gain=gain, clamp=clamp).apply(x, b) + return _bias_act_ref(x=x, b=b, dim=dim, act=act, alpha=alpha, gain=gain, clamp=clamp) + +#---------------------------------------------------------------------------- + +@misc.profiled_function +def _bias_act_ref(x, b=None, dim=1, act='linear', alpha=None, gain=None, clamp=None): + """Slow reference implementation of `bias_act()` using standard TensorFlow ops. + """ + assert isinstance(x, torch.Tensor) + assert clamp is None or clamp >= 0 + spec = activation_funcs[act] + alpha = float(alpha if alpha is not None else spec.def_alpha) + gain = float(gain if gain is not None else spec.def_gain) + clamp = float(clamp if clamp is not None else -1) + + # Add bias. + if b is not None: + assert isinstance(b, torch.Tensor) and b.ndim == 1 + assert 0 <= dim < x.ndim + assert b.shape[0] == x.shape[dim] + x = x + b.reshape([-1 if i == dim else 1 for i in range(x.ndim)]) + + # Evaluate activation function. + alpha = float(alpha) + x = spec.func(x, alpha=alpha) + + # Scale by gain. + gain = float(gain) + if gain != 1: + x = x * gain + + # Clamp. + if clamp >= 0: + x = x.clamp(-clamp, clamp) # pylint: disable=invalid-unary-operand-type + return x + +#---------------------------------------------------------------------------- + +_bias_act_cuda_cache = dict() + +def _bias_act_cuda(dim=1, act='linear', alpha=None, gain=None, clamp=None): + """Fast CUDA implementation of `bias_act()` using custom ops. + """ + # Parse arguments. + assert clamp is None or clamp >= 0 + spec = activation_funcs[act] + alpha = float(alpha if alpha is not None else spec.def_alpha) + gain = float(gain if gain is not None else spec.def_gain) + clamp = float(clamp if clamp is not None else -1) + + # Lookup from cache. + key = (dim, act, alpha, gain, clamp) + if key in _bias_act_cuda_cache: + return _bias_act_cuda_cache[key] + + # Forward op. + class BiasActCuda(torch.autograd.Function): + @staticmethod + def forward(ctx, x, b): # pylint: disable=arguments-differ + ctx.memory_format = torch.channels_last if x.ndim > 2 and x.stride(1) == 1 else torch.contiguous_format + x = x.contiguous(memory_format=ctx.memory_format) + b = b.contiguous() if b is not None else _null_tensor + y = x + if act != 'linear' or gain != 1 or clamp >= 0 or b is not _null_tensor: + y = _plugin.bias_act(x, b, _null_tensor, _null_tensor, _null_tensor, 0, dim, spec.cuda_idx, alpha, gain, clamp) + ctx.save_for_backward( + x if 'x' in spec.ref or spec.has_2nd_grad else _null_tensor, + b if 'x' in spec.ref or spec.has_2nd_grad else _null_tensor, + y if 'y' in spec.ref else _null_tensor) + return y + + @staticmethod + def backward(ctx, dy): # pylint: disable=arguments-differ + dy = dy.contiguous(memory_format=ctx.memory_format) + x, b, y = ctx.saved_tensors + dx = None + db = None + + if ctx.needs_input_grad[0] or ctx.needs_input_grad[1]: + dx = dy + if act != 'linear' or gain != 1 or clamp >= 0: + dx = BiasActCudaGrad.apply(dy, x, b, y) + + if ctx.needs_input_grad[1]: + db = dx.sum([i for i in range(dx.ndim) if i != dim]) + + return dx, db + + # Backward op. + class BiasActCudaGrad(torch.autograd.Function): + @staticmethod + def forward(ctx, dy, x, b, y): # pylint: disable=arguments-differ + ctx.memory_format = torch.channels_last if dy.ndim > 2 and dy.stride(1) == 1 else torch.contiguous_format + dx = _plugin.bias_act(dy, b, x, y, _null_tensor, 1, dim, spec.cuda_idx, alpha, gain, clamp) + ctx.save_for_backward( + dy if spec.has_2nd_grad else _null_tensor, + x, b, y) + return dx + + @staticmethod + def backward(ctx, d_dx): # pylint: disable=arguments-differ + d_dx = d_dx.contiguous(memory_format=ctx.memory_format) + dy, x, b, y = ctx.saved_tensors + d_dy = None + d_x = None + d_b = None + d_y = None + + if ctx.needs_input_grad[0]: + d_dy = BiasActCudaGrad.apply(d_dx, x, b, y) + + if spec.has_2nd_grad and (ctx.needs_input_grad[1] or ctx.needs_input_grad[2]): + d_x = _plugin.bias_act(d_dx, b, x, y, dy, 2, dim, spec.cuda_idx, alpha, gain, clamp) + + if spec.has_2nd_grad and ctx.needs_input_grad[2]: + d_b = d_x.sum([i for i in range(d_x.ndim) if i != dim]) + + return d_dy, d_x, d_b, d_y + + # Add to cache. + _bias_act_cuda_cache[key] = BiasActCuda + return BiasActCuda + +#---------------------------------------------------------------------------- diff --git a/torch_utils/ops/conv2d_gradfix.py b/torch_utils/ops/conv2d_gradfix.py new file mode 100644 index 0000000..156b6b2 --- /dev/null +++ b/torch_utils/ops/conv2d_gradfix.py @@ -0,0 +1,203 @@ +# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +"""Custom replacement for `torch.nn.functional.conv2d` that supports +arbitrarily high order gradients with zero performance penalty.""" + +import contextlib +import torch +from pkg_resources import parse_version + +# pylint: disable=redefined-builtin +# pylint: disable=arguments-differ +# pylint: disable=protected-access + +#---------------------------------------------------------------------------- + +enabled = False # Enable the custom op by setting this to true. +weight_gradients_disabled = False # Forcefully disable computation of gradients with respect to the weights. +_use_pytorch_1_11_api = parse_version(torch.__version__) >= parse_version('1.11.0a') # Allow prerelease builds of 1.11 + +@contextlib.contextmanager +def no_weight_gradients(disable=True): + global weight_gradients_disabled + old = weight_gradients_disabled + if disable: + weight_gradients_disabled = True + yield + weight_gradients_disabled = old + +#---------------------------------------------------------------------------- + +def conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): + if _should_use_custom_op(input): + return _conv2d_gradfix(transpose=False, weight_shape=weight.shape, stride=stride, padding=padding, output_padding=0, dilation=dilation, groups=groups).apply(input, weight, bias) + return torch.nn.functional.conv2d(input=input, weight=weight, bias=bias, stride=stride, padding=padding, dilation=dilation, groups=groups) + +def conv_transpose2d(input, weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1): + if _should_use_custom_op(input): + return _conv2d_gradfix(transpose=True, weight_shape=weight.shape, stride=stride, padding=padding, output_padding=output_padding, groups=groups, dilation=dilation).apply(input, weight, bias) + return torch.nn.functional.conv_transpose2d(input=input, weight=weight, bias=bias, stride=stride, padding=padding, output_padding=output_padding, groups=groups, dilation=dilation) + +#---------------------------------------------------------------------------- + +def _should_use_custom_op(input): + assert isinstance(input, torch.Tensor) + if (not enabled) or (not torch.backends.cudnn.enabled): + return False + if _use_pytorch_1_11_api: + # The work-around code doesn't work on PyTorch 1.11.0 onwards + return False + if input.device.type != 'cuda': + return False + return True + +def _tuple_of_ints(xs, ndim): + xs = tuple(xs) if isinstance(xs, (tuple, list)) else (xs,) * ndim + assert len(xs) == ndim + assert all(isinstance(x, int) for x in xs) + return xs + +#---------------------------------------------------------------------------- + +_conv2d_gradfix_cache = dict() +_null_tensor = torch.empty([0]) + +def _conv2d_gradfix(transpose, weight_shape, stride, padding, output_padding, dilation, groups): + # Parse arguments. + ndim = 2 + weight_shape = tuple(weight_shape) + stride = _tuple_of_ints(stride, ndim) + padding = _tuple_of_ints(padding, ndim) + output_padding = _tuple_of_ints(output_padding, ndim) + dilation = _tuple_of_ints(dilation, ndim) + + # Lookup from cache. + key = (transpose, weight_shape, stride, padding, output_padding, dilation, groups) + if key in _conv2d_gradfix_cache: + return _conv2d_gradfix_cache[key] + + # Validate arguments. + assert groups >= 1 + assert len(weight_shape) == ndim + 2 + assert all(stride[i] >= 1 for i in range(ndim)) + assert all(padding[i] >= 0 for i in range(ndim)) + assert all(dilation[i] >= 0 for i in range(ndim)) + if not transpose: + assert all(output_padding[i] == 0 for i in range(ndim)) + else: # transpose + assert all(0 <= output_padding[i] < max(stride[i], dilation[i]) for i in range(ndim)) + + # Helpers. + common_kwargs = dict(stride=stride, padding=padding, dilation=dilation, groups=groups) + def calc_output_padding(input_shape, output_shape): + if transpose: + return [0, 0] + return [ + input_shape[i + 2] + - (output_shape[i + 2] - 1) * stride[i] + - (1 - 2 * padding[i]) + - dilation[i] * (weight_shape[i + 2] - 1) + for i in range(ndim) + ] + + # Forward & backward. + class Conv2d(torch.autograd.Function): + @staticmethod + def forward(ctx, input, weight, bias): + assert weight.shape == weight_shape + ctx.save_for_backward( + input if weight.requires_grad else _null_tensor, + weight if input.requires_grad else _null_tensor, + ) + ctx.input_shape = input.shape + + # Simple 1x1 convolution => cuBLAS (only on Volta, not on Ampere). + if weight_shape[2:] == stride == dilation == (1, 1) and padding == (0, 0) and torch.cuda.get_device_capability(input.device) < (8, 0): + a = weight.reshape(groups, weight_shape[0] // groups, weight_shape[1]) + b = input.reshape(input.shape[0], groups, input.shape[1] // groups, -1) + c = (a.transpose(1, 2) if transpose else a) @ b.permute(1, 2, 0, 3).flatten(2) + c = c.reshape(-1, input.shape[0], *input.shape[2:]).transpose(0, 1) + c = c if bias is None else c + bias.unsqueeze(0).unsqueeze(2).unsqueeze(3) + return c.contiguous(memory_format=(torch.channels_last if input.stride(1) == 1 else torch.contiguous_format)) + + # General case => cuDNN. + if transpose: + return torch.nn.functional.conv_transpose2d(input=input, weight=weight, bias=bias, output_padding=output_padding, **common_kwargs) + return torch.nn.functional.conv2d(input=input, weight=weight, bias=bias, **common_kwargs) + + @staticmethod + def backward(ctx, grad_output): + input, weight = ctx.saved_tensors + input_shape = ctx.input_shape + grad_input = None + grad_weight = None + grad_bias = None + + if ctx.needs_input_grad[0]: + p = calc_output_padding(input_shape=input_shape, output_shape=grad_output.shape) + op = _conv2d_gradfix(transpose=(not transpose), weight_shape=weight_shape, output_padding=p, **common_kwargs) + grad_input = op.apply(grad_output, weight, None) + assert grad_input.shape == input_shape + + if ctx.needs_input_grad[1] and not weight_gradients_disabled: + grad_weight = Conv2dGradWeight.apply(grad_output, input) + assert grad_weight.shape == weight_shape + + if ctx.needs_input_grad[2]: + grad_bias = grad_output.sum([0, 2, 3]) + + return grad_input, grad_weight, grad_bias + + # Gradient with respect to the weights. + class Conv2dGradWeight(torch.autograd.Function): + @staticmethod + def forward(ctx, grad_output, input): + ctx.save_for_backward( + grad_output if input.requires_grad else _null_tensor, + input if grad_output.requires_grad else _null_tensor, + ) + ctx.grad_output_shape = grad_output.shape + ctx.input_shape = input.shape + + # Simple 1x1 convolution => cuBLAS (on both Volta and Ampere). + if weight_shape[2:] == stride == dilation == (1, 1) and padding == (0, 0): + a = grad_output.reshape(grad_output.shape[0], groups, grad_output.shape[1] // groups, -1).permute(1, 2, 0, 3).flatten(2) + b = input.reshape(input.shape[0], groups, input.shape[1] // groups, -1).permute(1, 2, 0, 3).flatten(2) + c = (b @ a.transpose(1, 2) if transpose else a @ b.transpose(1, 2)).reshape(weight_shape) + return c.contiguous(memory_format=(torch.channels_last if input.stride(1) == 1 else torch.contiguous_format)) + + # General case => cuDNN. + name = 'aten::cudnn_convolution_transpose_backward_weight' if transpose else 'aten::cudnn_convolution_backward_weight' + flags = [torch.backends.cudnn.benchmark, torch.backends.cudnn.deterministic, torch.backends.cudnn.allow_tf32] + return torch._C._jit_get_operation(name)(weight_shape, grad_output, input, padding, stride, dilation, groups, *flags) + + @staticmethod + def backward(ctx, grad2_grad_weight): + grad_output, input = ctx.saved_tensors + grad_output_shape = ctx.grad_output_shape + input_shape = ctx.input_shape + grad2_grad_output = None + grad2_input = None + + if ctx.needs_input_grad[0]: + grad2_grad_output = Conv2d.apply(input, grad2_grad_weight, None) + assert grad2_grad_output.shape == grad_output_shape + + if ctx.needs_input_grad[1]: + p = calc_output_padding(input_shape=input_shape, output_shape=grad_output_shape) + op = _conv2d_gradfix(transpose=(not transpose), weight_shape=weight_shape, output_padding=p, **common_kwargs) + grad2_input = op.apply(grad_output, grad2_grad_weight, None) + assert grad2_input.shape == input_shape + + return grad2_grad_output, grad2_input + + _conv2d_gradfix_cache[key] = Conv2d + return Conv2d + +#---------------------------------------------------------------------------- diff --git a/torch_utils/ops/conv2d_resample.py b/torch_utils/ops/conv2d_resample.py new file mode 100644 index 0000000..5eb5877 --- /dev/null +++ b/torch_utils/ops/conv2d_resample.py @@ -0,0 +1,143 @@ +# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +"""2D convolution with optional up/downsampling.""" + +import torch + +from .. import misc +from . import conv2d_gradfix +from . import upfirdn2d +from .upfirdn2d import _parse_padding +from .upfirdn2d import _get_filter_size + +#---------------------------------------------------------------------------- + +def _get_weight_shape(w): + with misc.suppress_tracer_warnings(): # this value will be treated as a constant + shape = [int(sz) for sz in w.shape] + misc.assert_shape(w, shape) + return shape + +#---------------------------------------------------------------------------- + +def _conv2d_wrapper(x, w, stride=1, padding=0, groups=1, transpose=False, flip_weight=True): + """Wrapper for the underlying `conv2d()` and `conv_transpose2d()` implementations. + """ + _out_channels, _in_channels_per_group, kh, kw = _get_weight_shape(w) + + # Flip weight if requested. + # Note: conv2d() actually performs correlation (flip_weight=True) not convolution (flip_weight=False). + if not flip_weight and (kw > 1 or kh > 1): + w = w.flip([2, 3]) + + # Execute using conv2d_gradfix. + op = conv2d_gradfix.conv_transpose2d if transpose else conv2d_gradfix.conv2d + return op(x, w, stride=stride, padding=padding, groups=groups) + +#---------------------------------------------------------------------------- + +@misc.profiled_function +def conv2d_resample(x, w, f=None, up=1, down=1, padding=0, groups=1, flip_weight=True, flip_filter=False): + r"""2D convolution with optional up/downsampling. + + Padding is performed only once at the beginning, not between the operations. + + Args: + x: Input tensor of shape + `[batch_size, in_channels, in_height, in_width]`. + w: Weight tensor of shape + `[out_channels, in_channels//groups, kernel_height, kernel_width]`. + f: Low-pass filter for up/downsampling. Must be prepared beforehand by + calling upfirdn2d.setup_filter(). None = identity (default). + up: Integer upsampling factor (default: 1). + down: Integer downsampling factor (default: 1). + padding: Padding with respect to the upsampled image. Can be a single number + or a list/tuple `[x, y]` or `[x_before, x_after, y_before, y_after]` + (default: 0). + groups: Split input channels into N groups (default: 1). + flip_weight: False = convolution, True = correlation (default: True). + flip_filter: False = convolution, True = correlation (default: False). + + Returns: + Tensor of the shape `[batch_size, num_channels, out_height, out_width]`. + """ + # Validate arguments. + assert isinstance(x, torch.Tensor) and (x.ndim == 4) + assert isinstance(w, torch.Tensor) and (w.ndim == 4) and (w.dtype == x.dtype) + assert f is None or (isinstance(f, torch.Tensor) and f.ndim in [1, 2] and f.dtype == torch.float32) + assert isinstance(up, int) and (up >= 1) + assert isinstance(down, int) and (down >= 1) + assert isinstance(groups, int) and (groups >= 1) + out_channels, in_channels_per_group, kh, kw = _get_weight_shape(w) + fw, fh = _get_filter_size(f) + px0, px1, py0, py1 = _parse_padding(padding) + + # Adjust padding to account for up/downsampling. + if up > 1: + px0 += (fw + up - 1) // 2 + px1 += (fw - up) // 2 + py0 += (fh + up - 1) // 2 + py1 += (fh - up) // 2 + if down > 1: + px0 += (fw - down + 1) // 2 + px1 += (fw - down) // 2 + py0 += (fh - down + 1) // 2 + py1 += (fh - down) // 2 + + # Fast path: 1x1 convolution with downsampling only => downsample first, then convolve. + if kw == 1 and kh == 1 and (down > 1 and up == 1): + x = upfirdn2d.upfirdn2d(x=x, f=f, down=down, padding=[px0,px1,py0,py1], flip_filter=flip_filter) + x = _conv2d_wrapper(x=x, w=w, groups=groups, flip_weight=flip_weight) + return x + + # Fast path: 1x1 convolution with upsampling only => convolve first, then upsample. + if kw == 1 and kh == 1 and (up > 1 and down == 1): + x = _conv2d_wrapper(x=x, w=w, groups=groups, flip_weight=flip_weight) + x = upfirdn2d.upfirdn2d(x=x, f=f, up=up, padding=[px0,px1,py0,py1], gain=up**2, flip_filter=flip_filter) + return x + + # Fast path: downsampling only => use strided convolution. + if down > 1 and up == 1: + x = upfirdn2d.upfirdn2d(x=x, f=f, padding=[px0,px1,py0,py1], flip_filter=flip_filter) + x = _conv2d_wrapper(x=x, w=w, stride=down, groups=groups, flip_weight=flip_weight) + return x + + # Fast path: upsampling with optional downsampling => use transpose strided convolution. + if up > 1: + if groups == 1: + w = w.transpose(0, 1) + else: + w = w.reshape(groups, out_channels // groups, in_channels_per_group, kh, kw) + w = w.transpose(1, 2) + w = w.reshape(groups * in_channels_per_group, out_channels // groups, kh, kw) + px0 -= kw - 1 + px1 -= kw - up + py0 -= kh - 1 + py1 -= kh - up + pxt = max(min(-px0, -px1), 0) + pyt = max(min(-py0, -py1), 0) + x = _conv2d_wrapper(x=x, w=w, stride=up, padding=[pyt,pxt], groups=groups, transpose=True, flip_weight=(not flip_weight)) + x = upfirdn2d.upfirdn2d(x=x, f=f, padding=[px0+pxt,px1+pxt,py0+pyt,py1+pyt], gain=up**2, flip_filter=flip_filter) + if down > 1: + x = upfirdn2d.upfirdn2d(x=x, f=f, down=down, flip_filter=flip_filter) + return x + + # Fast path: no up/downsampling, padding supported by the underlying implementation => use plain conv2d. + if up == 1 and down == 1: + if px0 == px1 and py0 == py1 and px0 >= 0 and py0 >= 0: + return _conv2d_wrapper(x=x, w=w, padding=[py0,px0], groups=groups, flip_weight=flip_weight) + + # Fallback: Generic reference implementation. + x = upfirdn2d.upfirdn2d(x=x, f=(f if up > 1 else None), up=up, padding=[px0,px1,py0,py1], gain=up**2, flip_filter=flip_filter) + x = _conv2d_wrapper(x=x, w=w, groups=groups, flip_weight=flip_weight) + if down > 1: + x = upfirdn2d.upfirdn2d(x=x, f=f, down=down, flip_filter=flip_filter) + return x + +#---------------------------------------------------------------------------- diff --git a/torch_utils/ops/filtered_lrelu.cpp b/torch_utils/ops/filtered_lrelu.cpp new file mode 100644 index 0000000..ff4149b --- /dev/null +++ b/torch_utils/ops/filtered_lrelu.cpp @@ -0,0 +1,300 @@ +// Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + +#include +#include +#include +#include "filtered_lrelu.h" + +//------------------------------------------------------------------------ + +static std::tuple filtered_lrelu( + torch::Tensor x, torch::Tensor fu, torch::Tensor fd, torch::Tensor b, torch::Tensor si, + int up, int down, int px0, int px1, int py0, int py1, int sx, int sy, float gain, float slope, float clamp, bool flip_filters, bool writeSigns) +{ + // Set CUDA device. + TORCH_CHECK(x.is_cuda(), "x must reside on CUDA device"); + const at::cuda::OptionalCUDAGuard device_guard(device_of(x)); + + // Validate arguments. + TORCH_CHECK(fu.device() == x.device() && fd.device() == x.device() && b.device() == x.device(), "all input tensors must reside on the same device"); + TORCH_CHECK(fu.dtype() == torch::kFloat && fd.dtype() == torch::kFloat, "fu and fd must be float32"); + TORCH_CHECK(b.dtype() == x.dtype(), "x and b must have the same dtype"); + TORCH_CHECK(x.dtype() == torch::kHalf || x.dtype() == torch::kFloat, "x and b must be float16 or float32"); + TORCH_CHECK(x.dim() == 4, "x must be rank 4"); + TORCH_CHECK(x.size(0) * x.size(1) <= INT_MAX && x.size(2) <= INT_MAX && x.size(3) <= INT_MAX, "x is too large"); + TORCH_CHECK(x.numel() > 0, "x is empty"); + TORCH_CHECK((fu.dim() == 1 || fu.dim() == 2) && (fd.dim() == 1 || fd.dim() == 2), "fu and fd must be rank 1 or 2"); + TORCH_CHECK(fu.size(0) <= INT_MAX && fu.size(-1) <= INT_MAX, "fu is too large"); + TORCH_CHECK(fd.size(0) <= INT_MAX && fd.size(-1) <= INT_MAX, "fd is too large"); + TORCH_CHECK(fu.numel() > 0, "fu is empty"); + TORCH_CHECK(fd.numel() > 0, "fd is empty"); + TORCH_CHECK(b.dim() == 1 && b.size(0) == x.size(1), "b must be a vector with the same number of channels as x"); + TORCH_CHECK(up >= 1 && down >= 1, "up and down must be at least 1"); + + // Figure out how much shared memory is available on the device. + int maxSharedBytes = 0; + AT_CUDA_CHECK(cudaDeviceGetAttribute(&maxSharedBytes, cudaDevAttrMaxSharedMemoryPerBlockOptin, x.device().index())); + int sharedKB = maxSharedBytes >> 10; + + // Populate enough launch parameters to check if a CUDA kernel exists. + filtered_lrelu_kernel_params p; + p.up = up; + p.down = down; + p.fuShape = make_int2((int)fu.size(-1), fu.dim() == 2 ? (int)fu.size(0) : 0); // shape [n, 0] indicates separable filter. + p.fdShape = make_int2((int)fd.size(-1), fd.dim() == 2 ? (int)fd.size(0) : 0); + filtered_lrelu_kernel_spec test_spec = choose_filtered_lrelu_kernel(p, sharedKB); + if (!test_spec.exec) + { + // No kernel found - return empty tensors and indicate missing kernel with return code of -1. + return std::make_tuple(torch::Tensor(), torch::Tensor(), -1); + } + + // Input/output element size. + int64_t sz = (x.dtype() == torch::kHalf) ? 2 : 4; + + // Input sizes. + int64_t xw = (int)x.size(3); + int64_t xh = (int)x.size(2); + int64_t fut_w = (int)fu.size(-1) - 1; + int64_t fut_h = (int)fu.size(0) - 1; + int64_t fdt_w = (int)fd.size(-1) - 1; + int64_t fdt_h = (int)fd.size(0) - 1; + + // Logical size of upsampled buffer. + int64_t cw = xw * up + (px0 + px1) - fut_w; + int64_t ch = xh * up + (py0 + py1) - fut_h; + TORCH_CHECK(cw > fdt_w && ch > fdt_h, "upsampled buffer must be at least the size of downsampling filter"); + TORCH_CHECK(cw <= INT_MAX && ch <= INT_MAX, "upsampled buffer is too large"); + + // Compute output size and allocate. + int64_t yw = (cw - fdt_w + (down - 1)) / down; + int64_t yh = (ch - fdt_h + (down - 1)) / down; + TORCH_CHECK(yw > 0 && yh > 0, "output must be at least 1x1"); + TORCH_CHECK(yw <= INT_MAX && yh <= INT_MAX, "output is too large"); + torch::Tensor y = torch::empty({x.size(0), x.size(1), yh, yw}, x.options(), x.suggest_memory_format()); + + // Allocate sign tensor. + torch::Tensor so; + torch::Tensor s = si; + bool readSigns = !!s.numel(); + int64_t sw_active = 0; // Active width of sign tensor. + if (writeSigns) + { + sw_active = yw * down - (down - 1) + fdt_w; // Active width in elements. + int64_t sh = yh * down - (down - 1) + fdt_h; // Height = active height. + int64_t sw = (sw_active + 15) & ~15; // Width = active width in elements, rounded up to multiple of 16. + TORCH_CHECK(sh <= INT_MAX && (sw >> 2) <= INT_MAX, "signs is too large"); + s = so = torch::empty({x.size(0), x.size(1), sh, sw >> 2}, x.options().dtype(torch::kUInt8), at::MemoryFormat::Contiguous); + } + else if (readSigns) + sw_active = s.size(3) << 2; + + // Validate sign tensor if in use. + if (readSigns || writeSigns) + { + TORCH_CHECK(s.is_contiguous(), "signs must be contiguous"); + TORCH_CHECK(s.dtype() == torch::kUInt8, "signs must be uint8"); + TORCH_CHECK(s.device() == x.device(), "signs must reside on the same device as x"); + TORCH_CHECK(s.dim() == 4, "signs must be rank 4"); + TORCH_CHECK(s.size(0) == x.size(0) && s.size(1) == x.size(1), "signs must have same batch & channels as x"); + TORCH_CHECK(s.size(2) <= INT_MAX && s.size(3) <= INT_MAX, "signs is too large"); + } + + // Populate rest of CUDA kernel parameters. + p.x = x.data_ptr(); + p.y = y.data_ptr(); + p.b = b.data_ptr(); + p.s = (readSigns || writeSigns) ? s.data_ptr() : 0; + p.fu = fu.data_ptr(); + p.fd = fd.data_ptr(); + p.pad0 = make_int2(px0, py0); + p.gain = gain; + p.slope = slope; + p.clamp = clamp; + p.flip = (flip_filters) ? 1 : 0; + p.xShape = make_int4((int)x.size(3), (int)x.size(2), (int)x.size(1), (int)x.size(0)); + p.yShape = make_int4((int)y.size(3), (int)y.size(2), (int)y.size(1), (int)y.size(0)); + p.sShape = (readSigns || writeSigns) ? make_int2((int)s.size(3), (int)s.size(2)) : make_int2(0, 0); // Width is in bytes. Contiguous. + p.sOfs = make_int2(sx, sy); + p.swLimit = (sw_active + 3) >> 2; // Rounded up to bytes. + + // x, y, b strides are in bytes. + p.xStride = make_longlong4(sz * x.stride(3), sz * x.stride(2), sz * x.stride(1), sz * x.stride(0)); + p.yStride = make_longlong4(sz * y.stride(3), sz * y.stride(2), sz * y.stride(1), sz * y.stride(0)); + p.bStride = sz * b.stride(0); + + // fu, fd strides are in elements. + p.fuStride = make_longlong3(fu.stride(-1), fu.dim() == 2 ? fu.stride(0) : 0, 0); + p.fdStride = make_longlong3(fd.stride(-1), fd.dim() == 2 ? fd.stride(0) : 0, 0); + + // Determine if indices don't fit in int32. Support negative strides although Torch currently never produces those. + bool index64b = false; + if (std::abs(p.bStride * x.size(1)) > INT_MAX) index64b = true; + if (std::min(x.size(0) * p.xStride.w, 0ll) + std::min(x.size(1) * p.xStride.z, 0ll) + std::min(x.size(2) * p.xStride.y, 0ll) + std::min(x.size(3) * p.xStride.x, 0ll) < -INT_MAX) index64b = true; + if (std::max(x.size(0) * p.xStride.w, 0ll) + std::max(x.size(1) * p.xStride.z, 0ll) + std::max(x.size(2) * p.xStride.y, 0ll) + std::max(x.size(3) * p.xStride.x, 0ll) > INT_MAX) index64b = true; + if (std::min(y.size(0) * p.yStride.w, 0ll) + std::min(y.size(1) * p.yStride.z, 0ll) + std::min(y.size(2) * p.yStride.y, 0ll) + std::min(y.size(3) * p.yStride.x, 0ll) < -INT_MAX) index64b = true; + if (std::max(y.size(0) * p.yStride.w, 0ll) + std::max(y.size(1) * p.yStride.z, 0ll) + std::max(y.size(2) * p.yStride.y, 0ll) + std::max(y.size(3) * p.yStride.x, 0ll) > INT_MAX) index64b = true; + if (s.numel() > INT_MAX) index64b = true; + + // Choose CUDA kernel. + filtered_lrelu_kernel_spec spec = { 0 }; + AT_DISPATCH_FLOATING_TYPES_AND_HALF(x.scalar_type(), "filtered_lrelu_cuda", [&] + { + if constexpr (sizeof(scalar_t) <= 4) // Exclude doubles. constexpr prevents template instantiation. + { + // Choose kernel based on index type, datatype and sign read/write modes. + if (!index64b && writeSigns && !readSigns) spec = choose_filtered_lrelu_kernel(p, sharedKB); + else if (!index64b && !writeSigns && readSigns) spec = choose_filtered_lrelu_kernel(p, sharedKB); + else if (!index64b && !writeSigns && !readSigns) spec = choose_filtered_lrelu_kernel(p, sharedKB); + else if ( index64b && writeSigns && !readSigns) spec = choose_filtered_lrelu_kernel(p, sharedKB); + else if ( index64b && !writeSigns && readSigns) spec = choose_filtered_lrelu_kernel(p, sharedKB); + else if ( index64b && !writeSigns && !readSigns) spec = choose_filtered_lrelu_kernel(p, sharedKB); + } + }); + TORCH_CHECK(spec.exec, "internal error - CUDA kernel not found") // This should not happen because we tested earlier that kernel exists. + + // Launch CUDA kernel. + void* args[] = {&p}; + int bx = spec.numWarps * 32; + int gx = (p.yShape.x - 1) / spec.tileOut.x + 1; + int gy = (p.yShape.y - 1) / spec.tileOut.y + 1; + int gz = p.yShape.z * p.yShape.w; + + // Repeat multiple horizontal tiles in a CTA? + if (spec.xrep) + { + p.tilesXrep = spec.xrep; + p.tilesXdim = gx; + + gx = (gx + p.tilesXrep - 1) / p.tilesXrep; + std::swap(gx, gy); + } + else + { + p.tilesXrep = 0; + p.tilesXdim = 0; + } + + // Launch filter setup kernel. + AT_CUDA_CHECK(cudaLaunchKernel(spec.setup, 1, 1024, args, 0, at::cuda::getCurrentCUDAStream())); + + // Copy kernels to constant memory. + if ( writeSigns && !readSigns) AT_CUDA_CHECK((copy_filters(at::cuda::getCurrentCUDAStream()))); + else if (!writeSigns && readSigns) AT_CUDA_CHECK((copy_filters(at::cuda::getCurrentCUDAStream()))); + else if (!writeSigns && !readSigns) AT_CUDA_CHECK((copy_filters(at::cuda::getCurrentCUDAStream()))); + + // Set cache and shared memory configurations for main kernel. + AT_CUDA_CHECK(cudaFuncSetCacheConfig(spec.exec, cudaFuncCachePreferShared)); + if (spec.dynamicSharedKB) // Need dynamically allocated shared memory? + AT_CUDA_CHECK(cudaFuncSetAttribute(spec.exec, cudaFuncAttributeMaxDynamicSharedMemorySize, spec.dynamicSharedKB << 10)); + AT_CUDA_CHECK(cudaFuncSetSharedMemConfig(spec.exec, cudaSharedMemBankSizeFourByte)); + + // Launch main kernel. + const int maxSubGz = 65535; // CUDA maximum for block z dimension. + for (int zofs=0; zofs < gz; zofs += maxSubGz) // Do multiple launches if gz is too big. + { + p.blockZofs = zofs; + int subGz = std::min(maxSubGz, gz - zofs); + AT_CUDA_CHECK(cudaLaunchKernel(spec.exec, dim3(gx, gy, subGz), bx, args, spec.dynamicSharedKB << 10, at::cuda::getCurrentCUDAStream())); + } + + // Done. + return std::make_tuple(y, so, 0); +} + +//------------------------------------------------------------------------ + +static torch::Tensor filtered_lrelu_act(torch::Tensor x, torch::Tensor si, int sx, int sy, float gain, float slope, float clamp, bool writeSigns) +{ + // Set CUDA device. + TORCH_CHECK(x.is_cuda(), "x must reside on CUDA device"); + const at::cuda::OptionalCUDAGuard device_guard(device_of(x)); + + // Validate arguments. + TORCH_CHECK(x.dim() == 4, "x must be rank 4"); + TORCH_CHECK(x.size(0) * x.size(1) <= INT_MAX && x.size(2) <= INT_MAX && x.size(3) <= INT_MAX, "x is too large"); + TORCH_CHECK(x.numel() > 0, "x is empty"); + TORCH_CHECK(x.dtype() == torch::kHalf || x.dtype() == torch::kFloat || x.dtype() == torch::kDouble, "x must be float16, float32 or float64"); + + // Output signs if we don't have sign input. + torch::Tensor so; + torch::Tensor s = si; + bool readSigns = !!s.numel(); + if (writeSigns) + { + int64_t sw = x.size(3); + sw = (sw + 15) & ~15; // Round to a multiple of 16 for coalescing. + s = so = torch::empty({x.size(0), x.size(1), x.size(2), sw >> 2}, x.options().dtype(torch::kUInt8), at::MemoryFormat::Contiguous); + } + + // Validate sign tensor if in use. + if (readSigns || writeSigns) + { + TORCH_CHECK(s.is_contiguous(), "signs must be contiguous"); + TORCH_CHECK(s.dtype() == torch::kUInt8, "signs must be uint8"); + TORCH_CHECK(s.device() == x.device(), "signs must reside on the same device as x"); + TORCH_CHECK(s.dim() == 4, "signs must be rank 4"); + TORCH_CHECK(s.size(0) == x.size(0) && s.size(1) == x.size(1), "signs must have same batch & channels as x"); + TORCH_CHECK(s.size(2) <= INT_MAX && (s.size(3) << 2) <= INT_MAX, "signs tensor is too large"); + } + + // Initialize CUDA kernel parameters. + filtered_lrelu_act_kernel_params p; + p.x = x.data_ptr(); + p.s = (readSigns || writeSigns) ? s.data_ptr() : 0; + p.gain = gain; + p.slope = slope; + p.clamp = clamp; + p.xShape = make_int4((int)x.size(3), (int)x.size(2), (int)x.size(1), (int)x.size(0)); + p.xStride = make_longlong4(x.stride(3), x.stride(2), x.stride(1), x.stride(0)); + p.sShape = (readSigns || writeSigns) ? make_int2((int)s.size(3) << 2, (int)s.size(2)) : make_int2(0, 0); // Width is in elements. Contiguous. + p.sOfs = make_int2(sx, sy); + + // Choose CUDA kernel. + void* func = 0; + AT_DISPATCH_FLOATING_TYPES_AND_HALF(x.scalar_type(), "filtered_lrelu_act_cuda", [&] + { + if (writeSigns) + func = choose_filtered_lrelu_act_kernel(); + else if (readSigns) + func = choose_filtered_lrelu_act_kernel(); + else + func = choose_filtered_lrelu_act_kernel(); + }); + TORCH_CHECK(func, "internal error - CUDA kernel not found"); + + // Launch CUDA kernel. + void* args[] = {&p}; + int bx = 128; // 4 warps per block. + + // Logical size of launch = writeSigns ? p.s : p.x + uint32_t gx = writeSigns ? p.sShape.x : p.xShape.x; + uint32_t gy = writeSigns ? p.sShape.y : p.xShape.y; + uint32_t gz = p.xShape.z * p.xShape.w; // Same as in p.sShape if signs are in use. + gx = (gx - 1) / bx + 1; + + // Make sure grid y and z dimensions are within CUDA launch limits. Kernel loops internally to do the rest. + const uint32_t gmax = 65535; + gy = std::min(gy, gmax); + gz = std::min(gz, gmax); + + // Launch. + AT_CUDA_CHECK(cudaLaunchKernel(func, dim3(gx, gy, gz), bx, args, 0, at::cuda::getCurrentCUDAStream())); + return so; +} + +//------------------------------------------------------------------------ + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) +{ + m.def("filtered_lrelu", &filtered_lrelu); // The whole thing. + m.def("filtered_lrelu_act_", &filtered_lrelu_act); // Activation and sign tensor handling only. Modifies data tensor in-place. +} + +//------------------------------------------------------------------------ diff --git a/torch_utils/ops/filtered_lrelu.cu b/torch_utils/ops/filtered_lrelu.cu new file mode 100644 index 0000000..8e6f47f --- /dev/null +++ b/torch_utils/ops/filtered_lrelu.cu @@ -0,0 +1,1284 @@ +// Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + +#include +#include "filtered_lrelu.h" +#include + +//------------------------------------------------------------------------ +// Helpers. + +enum // Filter modes. +{ + MODE_SUSD = 0, // Separable upsampling, separable downsampling. + MODE_FUSD = 1, // Full upsampling, separable downsampling. + MODE_SUFD = 2, // Separable upsampling, full downsampling. + MODE_FUFD = 3, // Full upsampling, full downsampling. +}; + +template struct InternalType; +template <> struct InternalType +{ + typedef double scalar_t; typedef double2 vec2_t; typedef double4 vec4_t; + __device__ __forceinline__ static vec2_t zero_vec2(void) { return make_double2(0, 0); } + __device__ __forceinline__ static vec4_t zero_vec4(void) { return make_double4(0, 0, 0, 0); } + __device__ __forceinline__ static double clamp(double x, double c) { return fmin(fmax(x, -c), c); } +}; +template <> struct InternalType +{ + typedef float scalar_t; typedef float2 vec2_t; typedef float4 vec4_t; + __device__ __forceinline__ static vec2_t zero_vec2(void) { return make_float2(0, 0); } + __device__ __forceinline__ static vec4_t zero_vec4(void) { return make_float4(0, 0, 0, 0); } + __device__ __forceinline__ static float clamp(float x, float c) { return fminf(fmaxf(x, -c), c); } +}; +template <> struct InternalType +{ + typedef float scalar_t; typedef float2 vec2_t; typedef float4 vec4_t; + __device__ __forceinline__ static vec2_t zero_vec2(void) { return make_float2(0, 0); } + __device__ __forceinline__ static vec4_t zero_vec4(void) { return make_float4(0, 0, 0, 0); } + __device__ __forceinline__ static float clamp(float x, float c) { return fminf(fmaxf(x, -c), c); } +}; + +#define MIN(A, B) ((A) < (B) ? (A) : (B)) +#define MAX(A, B) ((A) > (B) ? (A) : (B)) +#define CEIL_DIV(A, B) (((B)==1) ? (A) : \ + ((B)==2) ? ((int)((A)+1) >> 1) : \ + ((B)==4) ? ((int)((A)+3) >> 2) : \ + (((A) + ((A) > 0 ? (B) - 1 : 0)) / (B))) + +// This works only up to blocks of size 256 x 256 and for all N that are powers of two. +template __device__ __forceinline__ void fast_div_mod(int& x, int& y, unsigned int i) +{ + if ((N & (N-1)) && N <= 256) + y = (i * ((1<<24)/N + 1)) >> 24; // Assumes N <= 256, i < N*256. + else + y = i/N; + + x = i - y*N; +} + +// Type cast stride before reading it. +template __device__ __forceinline__ T get_stride(const int64_t& x) +{ + return *reinterpret_cast(&x); +} + +//------------------------------------------------------------------------ +// Filters, setup kernel, copying function. + +#define MAX_FILTER_SIZE 32 + +// Combined up/down filter buffers so that transfer can be done with one copy. +__device__ float g_fbuf[2 * MAX_FILTER_SIZE * MAX_FILTER_SIZE]; // Filters in global memory, written by setup kernel. +__device__ __constant__ float c_fbuf[2 * MAX_FILTER_SIZE * MAX_FILTER_SIZE]; // Filters in constant memory, read by main kernel. + +// Accessors to combined buffers to index up/down filters individually. +#define c_fu (c_fbuf) +#define c_fd (c_fbuf + MAX_FILTER_SIZE * MAX_FILTER_SIZE) +#define g_fu (g_fbuf) +#define g_fd (g_fbuf + MAX_FILTER_SIZE * MAX_FILTER_SIZE) + +// Set up filters into global memory buffer. +static __global__ void setup_filters_kernel(filtered_lrelu_kernel_params p) +{ + for (int idx = threadIdx.x; idx < MAX_FILTER_SIZE * MAX_FILTER_SIZE; idx += blockDim.x) + { + int x, y; + fast_div_mod(x, y, idx); + + int fu_x = p.flip ? x : (p.fuShape.x - 1 - x); + int fu_y = p.flip ? y : (p.fuShape.y - 1 - y); + if (p.fuShape.y > 0) + g_fu[idx] = (x >= p.fuShape.x || y >= p.fuShape.y) ? 0.0f : p.fu[fu_x * p.fuStride.x + fu_y * p.fuStride.y]; + else + g_fu[idx] = (x >= p.fuShape.x || y > 0) ? 0.0f : p.fu[fu_x * p.fuStride.x]; + + int fd_x = p.flip ? x : (p.fdShape.x - 1 - x); + int fd_y = p.flip ? y : (p.fdShape.y - 1 - y); + if (p.fdShape.y > 0) + g_fd[idx] = (x >= p.fdShape.x || y >= p.fdShape.y) ? 0.0f : p.fd[fd_x * p.fdStride.x + fd_y * p.fdStride.y]; + else + g_fd[idx] = (x >= p.fdShape.x || y > 0) ? 0.0f : p.fd[fd_x * p.fdStride.x]; + } +} + +// Host function to copy filters written by setup kernel into constant buffer for main kernel. +template static cudaError_t copy_filters(cudaStream_t stream) +{ + void* src = 0; + cudaError_t err = cudaGetSymbolAddress(&src, g_fbuf); + if (err) return err; + return cudaMemcpyToSymbolAsync(c_fbuf, src, 2 * MAX_FILTER_SIZE * MAX_FILTER_SIZE * sizeof(float), 0, cudaMemcpyDeviceToDevice, stream); +} + +//------------------------------------------------------------------------ +// Coordinate spaces: +// - Relative to input tensor: inX, inY, tileInX, tileInY +// - Relative to input tile: relInX, relInY, tileInW, tileInH +// - Relative to upsampled tile: relUpX, relUpY, tileUpW, tileUpH +// - Relative to output tile: relOutX, relOutY, tileOutW, tileOutH +// - Relative to output tensor: outX, outY, tileOutX, tileOutY +// +// Relationships between coordinate spaces: +// - inX = tileInX + relInX +// - inY = tileInY + relInY +// - relUpX = relInX * up + phaseInX +// - relUpY = relInY * up + phaseInY +// - relUpX = relOutX * down +// - relUpY = relOutY * down +// - outX = tileOutX + relOutX +// - outY = tileOutY + relOutY + +extern __shared__ char s_buf_raw[]; // When sharedKB <= 48, allocate shared memory statically inside the kernel, otherwise use the externally allocated shared memory buffer. + +template +static __global__ void filtered_lrelu_kernel(filtered_lrelu_kernel_params p) +{ + // Check that we don't try to support non-existing filter modes. + static_assert(up == 1 || up == 2 || up == 4, "only up=1, up=2, up=4 scales supported"); + static_assert(down == 1 || down == 2 || down == 4, "only down=1, down=2, down=4 scales supported"); + static_assert(fuSize >= up, "upsampling filter size must be at least upsampling factor"); + static_assert(fdSize >= down, "downsampling filter size must be at least downsampling factor"); + static_assert(fuSize % up == 0, "upsampling filter size must be divisible with upsampling factor"); + static_assert(fdSize % down == 0, "downsampling filter size must be divisible with downsampling factor"); + static_assert(fuSize <= MAX_FILTER_SIZE && fdSize <= MAX_FILTER_SIZE, "filter size greater than MAX_FILTER_SIZE"); + static_assert(up != 1 || (fuSize == 1 && (filterMode == MODE_FUFD || filterMode == MODE_FUSD)), "up=1 supported only for 1x1 full filters"); + static_assert(down != 1 || (fdSize == 1 && (filterMode == MODE_FUFD || filterMode == MODE_SUFD)), "down=1 supported only for 1x1 full filters"); + static_assert(!(up == 4 && (filterMode == MODE_FUFD || filterMode == MODE_FUSD)), "full filters not supported for up=4"); + static_assert(!(down == 4 && (filterMode == MODE_FUFD || filterMode == MODE_SUFD)), "full filters not supported for down=4"); + + // Static definitions. + typedef typename InternalType::scalar_t scalar_t; + typedef typename InternalType::vec2_t vec2_t; + typedef typename InternalType::vec4_t vec4_t; + const int tileUpW = (tileOutW * down + (fdSize - 1) - (down - 1) + 3) & ~3; // Upsampled tile width, rounded up to multiple of 4. + const int tileUpH = tileOutH * down + (fdSize - 1) - (down - 1); // Upsampled tile height. + const int tileInW = CEIL_DIV(tileUpW + (fuSize - 1), up); // Input tile width. + const int tileInH = CEIL_DIV(tileUpH + (fuSize - 1), up); // Input tile height. + const int tileUpH_up = CEIL_DIV(tileUpH, up) * up; // Upsampled tile height rounded up to a multiple of up. + const int tileInH_up = CEIL_DIV(tileUpH_up + (fuSize - 1), up); // For allocations only, to avoid shared memory read overruns with up=2 and up=4. + + // Merge 1x1 downsampling into last upsampling step for upf1 and ups2. + const bool downInline = (down == 1) && ((up == 1 && filterMode == MODE_FUFD) || (up == 2 && filterMode == MODE_SUFD)); + + // Sizes of logical buffers. + const int szIn = tileInH_up * tileInW; + const int szUpX = tileInH_up * tileUpW; + const int szUpXY = downInline ? 0 : (tileUpH * tileUpW); + const int szDownX = tileUpH * tileOutW; + + // Sizes for shared memory arrays. + const int s_buf0_size_base = + (filterMode == MODE_SUSD) ? MAX(szIn, szUpXY) : + (filterMode == MODE_FUSD) ? MAX(szIn, szDownX) : + (filterMode == MODE_SUFD) ? MAX(szIn, szUpXY) : + (filterMode == MODE_FUFD) ? szIn : + -1; + const int s_buf1_size_base = + (filterMode == MODE_SUSD) ? MAX(szUpX, szDownX) : + (filterMode == MODE_FUSD) ? szUpXY : + (filterMode == MODE_SUFD) ? szUpX : + (filterMode == MODE_FUFD) ? szUpXY : + -1; + + // Ensure U128 alignment. + const int s_buf0_size = (s_buf0_size_base + 3) & ~3; + const int s_buf1_size = (s_buf1_size_base + 3) & ~3; + + // Check at compile time that we don't use too much shared memory. + static_assert((s_buf0_size + s_buf1_size) * sizeof(scalar_t) <= (sharedKB << 10), "shared memory overflow"); + + // Declare shared memory arrays. + scalar_t* s_buf0; + scalar_t* s_buf1; + if (sharedKB <= 48) + { + // Allocate shared memory arrays here. + __shared__ scalar_t s_buf0_st[(sharedKB > 48) ? (1<<24) : (s_buf0_size + s_buf1_size)]; // Prevent launching if this isn't optimized away when unused. + s_buf0 = s_buf0_st; + s_buf1 = s_buf0 + s_buf0_size; + } + else + { + // Use the dynamically allocated shared memory array. + s_buf0 = (scalar_t*)s_buf_raw; + s_buf1 = s_buf0 + s_buf0_size; + } + + // Pointers to the buffers. + scalar_t* s_tileIn; // Input tile: [relInX * tileInH + relInY] + scalar_t* s_tileUpX; // After horizontal upsampling: [relInY * tileUpW + relUpX] + scalar_t* s_tileUpXY; // After upsampling: [relUpY * tileUpW + relUpX] + scalar_t* s_tileDownX; // After horizontal downsampling: [relUpY * tileOutW + relOutX] + if (filterMode == MODE_SUSD) + { + s_tileIn = s_buf0; + s_tileUpX = s_buf1; + s_tileUpXY = s_buf0; + s_tileDownX = s_buf1; + } + else if (filterMode == MODE_FUSD) + { + s_tileIn = s_buf0; + s_tileUpXY = s_buf1; + s_tileDownX = s_buf0; + } + else if (filterMode == MODE_SUFD) + { + s_tileIn = s_buf0; + s_tileUpX = s_buf1; + s_tileUpXY = s_buf0; + } + else if (filterMode == MODE_FUFD) + { + s_tileIn = s_buf0; + s_tileUpXY = s_buf1; + } + + // Allow large grids in z direction via per-launch offset. + int channelIdx = blockIdx.z + p.blockZofs; + int batchIdx = channelIdx / p.yShape.z; + channelIdx -= batchIdx * p.yShape.z; + + // Offset to output feature map. In bytes. + index_t mapOfsOut = channelIdx * get_stride(p.yStride.z) + batchIdx * get_stride(p.yStride.w); + + // Sign shift amount. + uint32_t signXo = ((threadIdx.x + p.sOfs.x) << 1) & 6; + + // Inner tile loop. + #pragma unroll 1 + for (int tileIdx = 0; !enableXrep || (tileIdx < MIN(p.tilesXrep, p.tilesXdim - p.tilesXrep * blockIdx.y)); tileIdx++) + { + // Locate output tile. + int tileX = enableXrep ? blockIdx.y * p.tilesXrep + tileIdx : blockIdx.x; + int tileOutX = tileX * tileOutW; + int tileOutY = (enableXrep ? blockIdx.x : blockIdx.y) * tileOutH; + + // Locate input tile. + int tmpX = tileOutX * down - p.pad0.x; + int tmpY = tileOutY * down - p.pad0.y; + int tileInX = CEIL_DIV(tmpX, up); + int tileInY = CEIL_DIV(tmpY, up); + const int phaseInX = tileInX * up - tmpX; + const int phaseInY = tileInY * up - tmpY; + + // Extra sync if input and output buffers are the same and we are not on first tile. + if (enableXrep && tileIdx > 0 && (filterMode == MODE_FUSD || (filterMode == MODE_SUFD && !downInline) || (filterMode == MODE_FUFD && downInline))) + __syncthreads(); + + // Load input tile & apply bias. Unrolled. + scalar_t b = (scalar_t)*(const T*)((const char*)p.b + (channelIdx * get_stride(p.bStride))); + index_t mapOfsIn = channelIdx * get_stride(p.xStride.z) + batchIdx * get_stride(p.xStride.w); + int idx = threadIdx.x; + const int loopCountIN = CEIL_DIV(tileInW * tileInH, threadsPerBlock); + #pragma unroll + for (int loop = 0; loop < loopCountIN; loop++) + { + int relInX, relInY; + fast_div_mod(relInX, relInY, idx); + int inX = tileInX + relInX; + int inY = tileInY + relInY; + scalar_t v = 0; + + if ((uint32_t)inX < p.xShape.x && (uint32_t)inY < p.xShape.y) + v = (scalar_t)*((const T*)((const char*)p.x + (inX * get_stride(p.xStride.x) + inY * get_stride(p.xStride.y) + mapOfsIn))) + b; + + bool skip = (loop == loopCountIN-1) && (idx >= tileInW * tileInH); + if (!skip) + s_tileIn[idx] = v; + + idx += threadsPerBlock; + } + + if (filterMode == MODE_SUSD || filterMode == MODE_SUFD) // Separable upsampling filter. + { + // Horizontal upsampling. + __syncthreads(); + if (up == 4) + { + for (int idx = threadIdx.x*up; idx < tileUpW * tileInH; idx += blockDim.x*up) + { + int relUpX0, relInY; + fast_div_mod(relUpX0, relInY, idx); + int relInX0 = relUpX0 / up; + int src0 = relInX0 + tileInW * relInY; + int dst = relInY * tileUpW + relUpX0; + vec4_t v = InternalType::zero_vec4(); + scalar_t a = s_tileIn[src0]; + if (phaseInX == 0) + { + #pragma unroll + for (int step = 0; step < fuSize / up; step++) + { + v.x += a * (scalar_t)c_fu[step * up + 0]; + a = s_tileIn[src0 + step + 1]; + v.y += a * (scalar_t)c_fu[step * up + 3]; + v.z += a * (scalar_t)c_fu[step * up + 2]; + v.w += a * (scalar_t)c_fu[step * up + 1]; + } + } + else if (phaseInX == 1) + { + #pragma unroll + for (int step = 0; step < fuSize / up; step++) + { + v.x += a * (scalar_t)c_fu[step * up + 1]; + v.y += a * (scalar_t)c_fu[step * up + 0]; + a = s_tileIn[src0 + step + 1]; + v.z += a * (scalar_t)c_fu[step * up + 3]; + v.w += a * (scalar_t)c_fu[step * up + 2]; + } + } + else if (phaseInX == 2) + { + #pragma unroll + for (int step = 0; step < fuSize / up; step++) + { + v.x += a * (scalar_t)c_fu[step * up + 2]; + v.y += a * (scalar_t)c_fu[step * up + 1]; + v.z += a * (scalar_t)c_fu[step * up + 0]; + a = s_tileIn[src0 + step + 1]; + v.w += a * (scalar_t)c_fu[step * up + 3]; + } + } + else // (phaseInX == 3) + { + #pragma unroll + for (int step = 0; step < fuSize / up; step++) + { + v.x += a * (scalar_t)c_fu[step * up + 3]; + v.y += a * (scalar_t)c_fu[step * up + 2]; + v.z += a * (scalar_t)c_fu[step * up + 1]; + v.w += a * (scalar_t)c_fu[step * up + 0]; + a = s_tileIn[src0 + step + 1]; + } + } + s_tileUpX[dst+0] = v.x; + s_tileUpX[dst+1] = v.y; + s_tileUpX[dst+2] = v.z; + s_tileUpX[dst+3] = v.w; + } + } + else if (up == 2) + { + bool p0 = (phaseInX == 0); + for (int idx = threadIdx.x*up; idx < tileUpW * tileInH; idx += blockDim.x*up) + { + int relUpX0, relInY; + fast_div_mod(relUpX0, relInY, idx); + int relInX0 = relUpX0 / up; + int src0 = relInX0 + tileInW * relInY; + int dst = relInY * tileUpW + relUpX0; + vec2_t v = InternalType::zero_vec2(); + scalar_t a = s_tileIn[src0]; + if (p0) // (phaseInX == 0) + { + #pragma unroll + for (int step = 0; step < fuSize / up; step++) + { + v.x += a * (scalar_t)c_fu[step * up + 0]; + a = s_tileIn[src0 + step + 1]; + v.y += a * (scalar_t)c_fu[step * up + 1]; + } + } + else // (phaseInX == 1) + { + #pragma unroll + for (int step = 0; step < fuSize / up; step++) + { + v.x += a * (scalar_t)c_fu[step * up + 1]; + v.y += a * (scalar_t)c_fu[step * up + 0]; + a = s_tileIn[src0 + step + 1]; + } + } + s_tileUpX[dst+0] = v.x; + s_tileUpX[dst+1] = v.y; + } + } + + // Vertical upsampling & nonlinearity. + + __syncthreads(); + int groupMask = 15 << ((threadIdx.x & 31) & ~3); + int minY = tileOutY ? (tileOutY - tileOutH) * down + tileUpH : 0; // Skip already written signs. + int sShapeMaxY = MIN(p.sShape.y, tileOutY * down + tileUpH); // Avoid out-of-tile sign writes. + if (up == 4) + { + minY -= 3; // Adjust according to block height. + for (int idx = threadIdx.x; idx < tileUpW * tileUpH_up / up; idx += blockDim.x) + { + int relUpX, relInY0; + fast_div_mod(relUpX, relInY0, idx); + int relUpY0 = relInY0 * up; + int src0 = relInY0 * tileUpW + relUpX; + int dst = relUpY0 * tileUpW + relUpX; + vec4_t v = InternalType::zero_vec4(); + + scalar_t a = s_tileUpX[src0]; + if (phaseInY == 0) + { + #pragma unroll + for (int step = 0; step < fuSize / up; step++) + { + v.x += a * (scalar_t)c_fu[step * up + 0]; + a = s_tileUpX[src0 + (step + 1) * tileUpW]; + v.y += a * (scalar_t)c_fu[step * up + 3]; + v.z += a * (scalar_t)c_fu[step * up + 2]; + v.w += a * (scalar_t)c_fu[step * up + 1]; + } + } + else if (phaseInY == 1) + { + #pragma unroll + for (int step = 0; step < fuSize / up; step++) + { + v.x += a * (scalar_t)c_fu[step * up + 1]; + v.y += a * (scalar_t)c_fu[step * up + 0]; + a = s_tileUpX[src0 + (step + 1) * tileUpW]; + v.z += a * (scalar_t)c_fu[step * up + 3]; + v.w += a * (scalar_t)c_fu[step * up + 2]; + } + } + else if (phaseInY == 2) + { + #pragma unroll + for (int step = 0; step < fuSize / up; step++) + { + v.x += a * (scalar_t)c_fu[step * up + 2]; + v.y += a * (scalar_t)c_fu[step * up + 1]; + v.z += a * (scalar_t)c_fu[step * up + 0]; + a = s_tileUpX[src0 + (step + 1) * tileUpW]; + v.w += a * (scalar_t)c_fu[step * up + 3]; + } + } + else // (phaseInY == 3) + { + #pragma unroll + for (int step = 0; step < fuSize / up; step++) + { + v.x += a * (scalar_t)c_fu[step * up + 3]; + v.y += a * (scalar_t)c_fu[step * up + 2]; + v.z += a * (scalar_t)c_fu[step * up + 1]; + v.w += a * (scalar_t)c_fu[step * up + 0]; + a = s_tileUpX[src0 + (step + 1) * tileUpW]; + } + } + + int x = tileOutX * down + relUpX; + int y = tileOutY * down + relUpY0; + int signX = x + p.sOfs.x; + int signY = y + p.sOfs.y; + int signZ = blockIdx.z + p.blockZofs; + int signXb = signX >> 2; + index_t si0 = signXb + p.sShape.x * (signY + (index_t)p.sShape.y * signZ); + index_t si1 = si0 + p.sShape.x; + index_t si2 = si0 + p.sShape.x * 2; + index_t si3 = si0 + p.sShape.x * 3; + + v.x *= (scalar_t)((float)up * (float)up * p.gain); + v.y *= (scalar_t)((float)up * (float)up * p.gain); + v.z *= (scalar_t)((float)up * (float)up * p.gain); + v.w *= (scalar_t)((float)up * (float)up * p.gain); + + if (signWrite) + { + if (!enableWriteSkip) + { + // Determine and write signs. + int sx = __float_as_uint(v.x) >> 31 << 0; + int sy = __float_as_uint(v.y) >> 31 << 8; + int sz = __float_as_uint(v.z) >> 31 << 16; + int sw = __float_as_uint(v.w) >> 31 << 24; + if (sx) v.x *= p.slope; + if (sy) v.y *= p.slope; + if (sz) v.z *= p.slope; + if (sw) v.w *= p.slope; + if (fabsf(v.x) > p.clamp) { sx = 2 << 0; v.x = InternalType::clamp(v.x, p.clamp); } + if (fabsf(v.y) > p.clamp) { sy = 2 << 8; v.y = InternalType::clamp(v.y, p.clamp); } + if (fabsf(v.z) > p.clamp) { sz = 2 << 16; v.z = InternalType::clamp(v.z, p.clamp); } + if (fabsf(v.w) > p.clamp) { sw = 2 << 24; v.w = InternalType::clamp(v.w, p.clamp); } + + if ((uint32_t)signXb < p.swLimit && signY >= minY) + { + // Combine signs. + uint32_t s = sx + sy + sw + sz; + s <<= (signX & 3) << 1; + s |= __shfl_xor_sync(groupMask, s, 1); + s |= __shfl_xor_sync(groupMask, s, 2); + + // Write signs. + if ((uint32_t)(signY + 0) < sShapeMaxY) { p.s[si0] = (unsigned char)(s >> 0); } + if ((uint32_t)(signY + 1) < sShapeMaxY) { p.s[si1] = (unsigned char)(s >> 8); } + if ((uint32_t)(signY + 2) < sShapeMaxY) { p.s[si2] = (unsigned char)(s >> 16); } + if ((uint32_t)(signY + 3) < sShapeMaxY) { p.s[si3] = (unsigned char)(s >> 24); } + } + } + else + { + // Determine and write signs. + if ((uint32_t)signXb < p.swLimit && signY >= minY) + { + int sx = __float_as_uint(v.x) >> 31 << 0; + int sy = __float_as_uint(v.y) >> 31 << 8; + int sz = __float_as_uint(v.z) >> 31 << 16; + int sw = __float_as_uint(v.w) >> 31 << 24; + if (sx) v.x *= p.slope; + if (sy) v.y *= p.slope; + if (sz) v.z *= p.slope; + if (sw) v.w *= p.slope; + if (fabsf(v.x) > p.clamp) { sx = 2 << 0; v.x = InternalType::clamp(v.x, p.clamp); } + if (fabsf(v.y) > p.clamp) { sy = 2 << 8; v.y = InternalType::clamp(v.y, p.clamp); } + if (fabsf(v.z) > p.clamp) { sz = 2 << 16; v.z = InternalType::clamp(v.z, p.clamp); } + if (fabsf(v.w) > p.clamp) { sw = 2 << 24; v.w = InternalType::clamp(v.w, p.clamp); } + + // Combine signs. + uint32_t s = sx + sy + sw + sz; + s <<= (signX & 3) << 1; + s |= __shfl_xor_sync(groupMask, s, 1); + s |= __shfl_xor_sync(groupMask, s, 2); + + // Write signs. + if ((uint32_t)(signY + 0) < sShapeMaxY) { p.s[si0] = (unsigned char)(s >> 0); } + if ((uint32_t)(signY + 1) < sShapeMaxY) { p.s[si1] = (unsigned char)(s >> 8); } + if ((uint32_t)(signY + 2) < sShapeMaxY) { p.s[si2] = (unsigned char)(s >> 16); } + if ((uint32_t)(signY + 3) < sShapeMaxY) { p.s[si3] = (unsigned char)(s >> 24); } + } + else + { + // Just compute the values. + if (v.x < 0.f) v.x *= p.slope; v.x = InternalType::clamp(v.x, p.clamp); + if (v.y < 0.f) v.y *= p.slope; v.y = InternalType::clamp(v.y, p.clamp); + if (v.z < 0.f) v.z *= p.slope; v.z = InternalType::clamp(v.z, p.clamp); + if (v.w < 0.f) v.w *= p.slope; v.w = InternalType::clamp(v.w, p.clamp); + } + } + } + else if (signRead) // Read signs and apply. + { + if ((uint32_t)signXb < p.swLimit) + { + int ss = (signX & 3) << 1; + if ((uint32_t)(signY + 0) < p.sShape.y) { int s = p.s[si0] >> ss; if (s & 1) v.x *= p.slope; if (s & 2) v.x = 0.f; } + if ((uint32_t)(signY + 1) < p.sShape.y) { int s = p.s[si1] >> ss; if (s & 1) v.y *= p.slope; if (s & 2) v.y = 0.f; } + if ((uint32_t)(signY + 2) < p.sShape.y) { int s = p.s[si2] >> ss; if (s & 1) v.z *= p.slope; if (s & 2) v.z = 0.f; } + if ((uint32_t)(signY + 3) < p.sShape.y) { int s = p.s[si3] >> ss; if (s & 1) v.w *= p.slope; if (s & 2) v.w = 0.f; } + } + } + else // Forward pass with no sign write. + { + if (v.x < 0.f) v.x *= p.slope; v.x = InternalType::clamp(v.x, p.clamp); + if (v.y < 0.f) v.y *= p.slope; v.y = InternalType::clamp(v.y, p.clamp); + if (v.z < 0.f) v.z *= p.slope; v.z = InternalType::clamp(v.z, p.clamp); + if (v.w < 0.f) v.w *= p.slope; v.w = InternalType::clamp(v.w, p.clamp); + } + + s_tileUpXY[dst + 0 * tileUpW] = v.x; + if (relUpY0 + 1 < tileUpH) s_tileUpXY[dst + 1 * tileUpW] = v.y; + if (relUpY0 + 2 < tileUpH) s_tileUpXY[dst + 2 * tileUpW] = v.z; + if (relUpY0 + 3 < tileUpH) s_tileUpXY[dst + 3 * tileUpW] = v.w; + } + } + else if (up == 2) + { + minY -= 1; // Adjust according to block height. + for (int idx = threadIdx.x; idx < tileUpW * tileUpH_up / up; idx += blockDim.x) + { + int relUpX, relInY0; + fast_div_mod(relUpX, relInY0, idx); + int relUpY0 = relInY0 * up; + int src0 = relInY0 * tileUpW + relUpX; + int dst = relUpY0 * tileUpW + relUpX; + vec2_t v = InternalType::zero_vec2(); + + scalar_t a = s_tileUpX[src0]; + if (phaseInY == 0) + { + #pragma unroll + for (int step = 0; step < fuSize / up; step++) + { + v.x += a * (scalar_t)c_fu[step * up + 0]; + a = s_tileUpX[src0 + (step + 1) * tileUpW]; + v.y += a * (scalar_t)c_fu[step * up + 1]; + } + } + else // (phaseInY == 1) + { + #pragma unroll + for (int step = 0; step < fuSize / up; step++) + { + v.x += a * (scalar_t)c_fu[step * up + 1]; + v.y += a * (scalar_t)c_fu[step * up + 0]; + a = s_tileUpX[src0 + (step + 1) * tileUpW]; + } + } + + int x = tileOutX * down + relUpX; + int y = tileOutY * down + relUpY0; + int signX = x + p.sOfs.x; + int signY = y + p.sOfs.y; + int signZ = blockIdx.z + p.blockZofs; + int signXb = signX >> 2; + index_t si0 = signXb + p.sShape.x * (signY + (index_t)p.sShape.y * signZ); + index_t si1 = si0 + p.sShape.x; + + v.x *= (scalar_t)((float)up * (float)up * p.gain); + v.y *= (scalar_t)((float)up * (float)up * p.gain); + + if (signWrite) + { + if (!enableWriteSkip) + { + // Determine and write signs. + int sx = __float_as_uint(v.x) >> 31 << 0; + int sy = __float_as_uint(v.y) >> 31 << 8; + if (sx) v.x *= p.slope; + if (sy) v.y *= p.slope; + if (fabsf(v.x) > p.clamp) { sx = 2 << 0; v.x = InternalType::clamp(v.x, p.clamp); } + if (fabsf(v.y) > p.clamp) { sy = 2 << 8; v.y = InternalType::clamp(v.y, p.clamp); } + + if ((uint32_t)signXb < p.swLimit && signY >= minY) + { + // Combine signs. + int s = sx + sy; + s <<= signXo; + s |= __shfl_xor_sync(groupMask, s, 1); + s |= __shfl_xor_sync(groupMask, s, 2); + + // Write signs. + if ((uint32_t)(signY + 0) < sShapeMaxY) { p.s[si0] = (unsigned char)(s >> 0); } + if ((uint32_t)(signY + 1) < sShapeMaxY) { p.s[si1] = (unsigned char)(s >> 8); } + } + } + else + { + // Determine and write signs. + if ((uint32_t)signXb < p.swLimit && signY >= minY) + { + int sx = __float_as_uint(v.x) >> 31 << 0; + int sy = __float_as_uint(v.y) >> 31 << 8; + if (sx) v.x *= p.slope; + if (sy) v.y *= p.slope; + if (fabsf(v.x) > p.clamp) { sx = 2 << 0; v.x = InternalType::clamp(v.x, p.clamp); } + if (fabsf(v.y) > p.clamp) { sy = 2 << 8; v.y = InternalType::clamp(v.y, p.clamp); } + + // Combine signs. + int s = sx + sy; + s <<= signXo; + s |= __shfl_xor_sync(groupMask, s, 1); + s |= __shfl_xor_sync(groupMask, s, 2); + + // Write signs. + if ((uint32_t)(signY + 0) < sShapeMaxY) { p.s[si0] = (unsigned char)(s >> 0); } + if ((uint32_t)(signY + 1) < sShapeMaxY) { p.s[si1] = (unsigned char)(s >> 8); } + } + else + { + // Just compute the values. + if (v.x < 0.f) v.x *= p.slope; v.x = InternalType::clamp(v.x, p.clamp); + if (v.y < 0.f) v.y *= p.slope; v.y = InternalType::clamp(v.y, p.clamp); + } + } + } + else if (signRead) // Read signs and apply. + { + if ((uint32_t)signXb < p.swLimit) + { + if ((uint32_t)(signY + 0) < p.sShape.y) { int s = p.s[si0] >> signXo; if (s & 1) v.x *= p.slope; if (s & 2) v.x = 0.f; } + if ((uint32_t)(signY + 1) < p.sShape.y) { int s = p.s[si1] >> signXo; if (s & 1) v.y *= p.slope; if (s & 2) v.y = 0.f; } + } + } + else // Forward pass with no sign write. + { + if (v.x < 0.f) v.x *= p.slope; v.x = InternalType::clamp(v.x, p.clamp); + if (v.y < 0.f) v.y *= p.slope; v.y = InternalType::clamp(v.y, p.clamp); + } + + if (!downInline) + { + // Write into temporary buffer. + s_tileUpXY[dst] = v.x; + if (relUpY0 < tileUpH - 1) + s_tileUpXY[dst + tileUpW] = v.y; + } + else + { + // Write directly into output buffer. + if ((uint32_t)x < p.yShape.x) + { + int ymax = MIN(p.yShape.y, tileUpH + tileOutY * down); + index_t ofs = x * get_stride(p.yStride.x) + y * get_stride(p.yStride.y) + mapOfsOut; + if ((uint32_t)y + 0 < p.yShape.y) *((T*)((char*)p.y + ofs)) = (T)(v.x * (scalar_t)c_fd[0]); + if ((uint32_t)y + 1 < ymax) *((T*)((char*)p.y + ofs + get_stride(p.yStride.y))) = (T)(v.y * (scalar_t)c_fd[0]); + } + } + } + } + } + else if (filterMode == MODE_FUSD || filterMode == MODE_FUFD) + { + // Full upsampling filter. + + if (up == 2) + { + // 2 x 2-wide. + __syncthreads(); + int minY = tileOutY ? (tileOutY - tileOutH) * down + tileUpH + p.sOfs.y : 0; // Skip already written signs. + for (int idx = threadIdx.x * 4; idx < tileUpW * tileUpH; idx += blockDim.x * 4) + { + int relUpX0, relUpY0; + fast_div_mod(relUpX0, relUpY0, idx); + int relInX0 = CEIL_DIV(relUpX0 - phaseInX, up); + int relInY0 = CEIL_DIV(relUpY0 - phaseInY, up); + int src0 = relInX0 + tileInW * relInY0; + int tap0y = (relInY0 * up + phaseInY - relUpY0); + + #define X_LOOP(TAPY, PX) \ + for (int sx = 0; sx < fuSize / up; sx++) \ + { \ + v.x += a * (scalar_t)c_fu[(sx * up + (((PX) - 0) & (up - 1))) + (sy * up + (TAPY)) * MAX_FILTER_SIZE]; \ + v.z += b * (scalar_t)c_fu[(sx * up + (((PX) - 0) & (up - 1))) + (sy * up + (TAPY)) * MAX_FILTER_SIZE]; if ((PX) == 0) { a = b; b = s_tileIn[src0 + 2 + sx + sy * tileInW]; } \ + v.y += a * (scalar_t)c_fu[(sx * up + (((PX) - 1) & (up - 1))) + (sy * up + (TAPY)) * MAX_FILTER_SIZE]; \ + v.w += b * (scalar_t)c_fu[(sx * up + (((PX) - 1) & (up - 1))) + (sy * up + (TAPY)) * MAX_FILTER_SIZE]; if ((PX) == 1) { a = b; b = s_tileIn[src0 + 2 + sx + sy * tileInW]; } \ + } + + vec4_t v = InternalType::zero_vec4(); + if (tap0y == 0 && phaseInX == 0) + #pragma unroll + for (int sy = 0; sy < fuSize / up; sy++) { scalar_t a = s_tileIn[src0 + sy * tileInW]; scalar_t b = s_tileIn[src0 + sy * tileInW + 1]; + #pragma unroll + X_LOOP(0, 0) } + if (tap0y == 0 && phaseInX == 1) + #pragma unroll + for (int sy = 0; sy < fuSize / up; sy++) { scalar_t a = s_tileIn[src0 + sy * tileInW]; scalar_t b = s_tileIn[src0 + sy * tileInW + 1]; + #pragma unroll + X_LOOP(0, 1) } + if (tap0y == 1 && phaseInX == 0) + #pragma unroll + for (int sy = 0; sy < fuSize / up; sy++) { scalar_t a = s_tileIn[src0 + sy * tileInW]; scalar_t b = s_tileIn[src0 + sy * tileInW + 1]; + #pragma unroll + X_LOOP(1, 0) } + if (tap0y == 1 && phaseInX == 1) + #pragma unroll + for (int sy = 0; sy < fuSize / up; sy++) { scalar_t a = s_tileIn[src0 + sy * tileInW]; scalar_t b = s_tileIn[src0 + sy * tileInW + 1]; + #pragma unroll + X_LOOP(1, 1) } + + #undef X_LOOP + + int x = tileOutX * down + relUpX0; + int y = tileOutY * down + relUpY0; + int signX = x + p.sOfs.x; + int signY = y + p.sOfs.y; + int signZ = blockIdx.z + p.blockZofs; + int signXb = signX >> 2; + index_t si = signXb + p.sShape.x * (signY + (index_t)p.sShape.y * signZ); + + v.x *= (scalar_t)((float)up * (float)up * p.gain); + v.y *= (scalar_t)((float)up * (float)up * p.gain); + v.z *= (scalar_t)((float)up * (float)up * p.gain); + v.w *= (scalar_t)((float)up * (float)up * p.gain); + + if (signWrite) + { + if (!enableWriteSkip) + { + // Determine and write signs. + int sx = __float_as_uint(v.x) >> 31; + int sy = __float_as_uint(v.y) >> 31; + int sz = __float_as_uint(v.z) >> 31; + int sw = __float_as_uint(v.w) >> 31; + if (sx) v.x *= p.slope; if (fabsf(v.x) > p.clamp) { sx = 2; v.x = InternalType::clamp(v.x, p.clamp); } + if (sy) v.y *= p.slope; if (fabsf(v.y) > p.clamp) { sy = 2; v.y = InternalType::clamp(v.y, p.clamp); } + if (sz) v.z *= p.slope; if (fabsf(v.z) > p.clamp) { sz = 2; v.z = InternalType::clamp(v.z, p.clamp); } + if (sw) v.w *= p.slope; if (fabsf(v.w) > p.clamp) { sw = 2; v.w = InternalType::clamp(v.w, p.clamp); } + + if ((uint32_t)signXb < p.swLimit && (uint32_t)signY < p.sShape.y && signY >= minY) + { + p.s[si] = sx + (sy << 2) + (sz << 4) + (sw << 6); + } + } + else + { + // Determine and write signs. + if ((uint32_t)signXb < p.swLimit && (uint32_t)signY < p.sShape.y && signY >= minY) + { + int sx = __float_as_uint(v.x) >> 31; + int sy = __float_as_uint(v.y) >> 31; + int sz = __float_as_uint(v.z) >> 31; + int sw = __float_as_uint(v.w) >> 31; + if (sx) v.x *= p.slope; if (fabsf(v.x) > p.clamp) { sx = 2; v.x = InternalType::clamp(v.x, p.clamp); } + if (sy) v.y *= p.slope; if (fabsf(v.y) > p.clamp) { sy = 2; v.y = InternalType::clamp(v.y, p.clamp); } + if (sz) v.z *= p.slope; if (fabsf(v.z) > p.clamp) { sz = 2; v.z = InternalType::clamp(v.z, p.clamp); } + if (sw) v.w *= p.slope; if (fabsf(v.w) > p.clamp) { sw = 2; v.w = InternalType::clamp(v.w, p.clamp); } + + p.s[si] = sx + (sy << 2) + (sz << 4) + (sw << 6); + } + else + { + // Just compute the values. + if (v.x < 0.f) v.x *= p.slope; v.x = InternalType::clamp(v.x, p.clamp); + if (v.y < 0.f) v.y *= p.slope; v.y = InternalType::clamp(v.y, p.clamp); + if (v.z < 0.f) v.z *= p.slope; v.z = InternalType::clamp(v.z, p.clamp); + if (v.w < 0.f) v.w *= p.slope; v.w = InternalType::clamp(v.w, p.clamp); + } + } + } + else if (signRead) // Read sign and apply. + { + if ((uint32_t)signY < p.sShape.y) + { + int s = 0; + if ((uint32_t)signXb < p.swLimit) s = p.s[si]; + if ((uint32_t)signXb + 1 < p.swLimit) s |= p.s[si + 1] << 8; + s >>= (signX & 3) << 1; + if (s & 0x01) v.x *= p.slope; if (s & 0x02) v.x = 0.f; + if (s & 0x04) v.y *= p.slope; if (s & 0x08) v.y = 0.f; + if (s & 0x10) v.z *= p.slope; if (s & 0x20) v.z = 0.f; + if (s & 0x40) v.w *= p.slope; if (s & 0x80) v.w = 0.f; + } + } + else // Forward pass with no sign write. + { + if (v.x < 0.f) v.x *= p.slope; v.x = InternalType::clamp(v.x, p.clamp); + if (v.y < 0.f) v.y *= p.slope; v.y = InternalType::clamp(v.y, p.clamp); + if (v.z < 0.f) v.z *= p.slope; v.z = InternalType::clamp(v.z, p.clamp); + if (v.w < 0.f) v.w *= p.slope; v.w = InternalType::clamp(v.w, p.clamp); + } + + s_tileUpXY[idx + 0] = v.x; + s_tileUpXY[idx + 1] = v.y; + s_tileUpXY[idx + 2] = v.z; + s_tileUpXY[idx + 3] = v.w; + } + } + else if (up == 1) + { + __syncthreads(); + uint32_t groupMask = 15 << ((threadIdx.x & 31) & ~3); + int minY = tileOutY ? (tileOutY - tileOutH) * down + tileUpH : 0; // Skip already written signs. + for (int idx = threadIdx.x; idx < tileUpW * tileUpH; idx += blockDim.x) + { + int relUpX0, relUpY0; + fast_div_mod(relUpX0, relUpY0, idx); + scalar_t v = s_tileIn[idx] * (scalar_t)c_fu[0]; // 1x1 filter. + + int x = tileOutX * down + relUpX0; + int y = tileOutY * down + relUpY0; + int signX = x + p.sOfs.x; + int signY = y + p.sOfs.y; + int signZ = blockIdx.z + p.blockZofs; + int signXb = signX >> 2; + index_t si = signXb + p.sShape.x * (signY + (index_t)p.sShape.y * signZ); + v *= (scalar_t)((float)up * (float)up * p.gain); + + if (signWrite) + { + if (!enableWriteSkip) + { + // Determine and write sign. + uint32_t s = 0; + uint32_t signXbit = (1u << signXo); + if (v < 0.f) + { + s = signXbit; + v *= p.slope; + } + if (fabsf(v) > p.clamp) + { + s = signXbit * 2; + v = InternalType::clamp(v, p.clamp); + } + if ((uint32_t)signXb < p.swLimit && (uint32_t)signY < p.sShape.y && signY >= minY) + { + s += __shfl_xor_sync(groupMask, s, 1); // Coalesce. + s += __shfl_xor_sync(groupMask, s, 2); // Coalesce. + p.s[si] = s; // Write. + } + } + else + { + // Determine and write sign. + if ((uint32_t)signXb < p.swLimit && (uint32_t)signY < p.sShape.y && signY >= minY) + { + uint32_t s = 0; + uint32_t signXbit = (1u << signXo); + if (v < 0.f) + { + s = signXbit; + v *= p.slope; + } + if (fabsf(v) > p.clamp) + { + s = signXbit * 2; + v = InternalType::clamp(v, p.clamp); + } + s += __shfl_xor_sync(groupMask, s, 1); // Coalesce. + s += __shfl_xor_sync(groupMask, s, 2); // Coalesce. + p.s[si] = s; // Write. + } + else + { + // Just compute the value. + if (v < 0.f) v *= p.slope; + v = InternalType::clamp(v, p.clamp); + } + } + } + else if (signRead) + { + // Read sign and apply if within sign tensor bounds. + if ((uint32_t)signXb < p.swLimit && (uint32_t)signY < p.sShape.y) + { + int s = p.s[si]; + s >>= signXo; + if (s & 1) v *= p.slope; + if (s & 2) v = 0.f; + } + } + else // Forward pass with no sign write. + { + if (v < 0.f) v *= p.slope; + v = InternalType::clamp(v, p.clamp); + } + + if (!downInline) // Write into temporary buffer. + s_tileUpXY[idx] = v; + else if ((uint32_t)x < p.yShape.x && (uint32_t)y < p.yShape.y) // Write directly into output buffer + *((T*)((char*)p.y + (x * get_stride(p.yStride.x) + y * get_stride(p.yStride.y) + mapOfsOut))) = (T)(v * (scalar_t)c_fd[0]); + } + } + } + + // Downsampling. + if (filterMode == MODE_SUSD || filterMode == MODE_FUSD) + { + // Horizontal downsampling. + __syncthreads(); + if (down == 4 && tileOutW % 4 == 0) + { + // Calculate 4 pixels at a time. + for (int idx = threadIdx.x * 4; idx < tileOutW * tileUpH; idx += blockDim.x * 4) + { + int relOutX0, relUpY; + fast_div_mod(relOutX0, relUpY, idx); + int relUpX0 = relOutX0 * down; + int src0 = relUpY * tileUpW + relUpX0; + vec4_t v = InternalType::zero_vec4(); + #pragma unroll + for (int step = 0; step < fdSize; step++) + { + v.x += s_tileUpXY[src0 + 0 + step] * (scalar_t)c_fd[step]; + v.y += s_tileUpXY[src0 + 4 + step] * (scalar_t)c_fd[step]; + v.z += s_tileUpXY[src0 + 8 + step] * (scalar_t)c_fd[step]; + v.w += s_tileUpXY[src0 + 12 + step] * (scalar_t)c_fd[step]; + } + s_tileDownX[idx+0] = v.x; + s_tileDownX[idx+1] = v.y; + s_tileDownX[idx+2] = v.z; + s_tileDownX[idx+3] = v.w; + } + } + else if ((down == 2 || down == 4) && (tileOutW % 2 == 0)) + { + // Calculate 2 pixels at a time. + for (int idx = threadIdx.x * 2; idx < tileOutW * tileUpH; idx += blockDim.x * 2) + { + int relOutX0, relUpY; + fast_div_mod(relOutX0, relUpY, idx); + int relUpX0 = relOutX0 * down; + int src0 = relUpY * tileUpW + relUpX0; + vec2_t v = InternalType::zero_vec2(); + #pragma unroll + for (int step = 0; step < fdSize; step++) + { + v.x += s_tileUpXY[src0 + 0 + step] * (scalar_t)c_fd[step]; + v.y += s_tileUpXY[src0 + down + step] * (scalar_t)c_fd[step]; + } + s_tileDownX[idx+0] = v.x; + s_tileDownX[idx+1] = v.y; + } + } + else + { + // Calculate 1 pixel at a time. + for (int idx = threadIdx.x; idx < tileOutW * tileUpH; idx += blockDim.x) + { + int relOutX0, relUpY; + fast_div_mod(relOutX0, relUpY, idx); + int relUpX0 = relOutX0 * down; + int src = relUpY * tileUpW + relUpX0; + scalar_t v = 0.f; + #pragma unroll + for (int step = 0; step < fdSize; step++) + v += s_tileUpXY[src + step] * (scalar_t)c_fd[step]; + s_tileDownX[idx] = v; + } + } + + // Vertical downsampling & store output tile. + __syncthreads(); + for (int idx = threadIdx.x; idx < tileOutW * tileOutH; idx += blockDim.x) + { + int relOutX, relOutY0; + fast_div_mod(relOutX, relOutY0, idx); + int relUpY0 = relOutY0 * down; + int src0 = relUpY0 * tileOutW + relOutX; + scalar_t v = 0; + #pragma unroll + for (int step = 0; step < fdSize; step++) + v += s_tileDownX[src0 + step * tileOutW] * (scalar_t)c_fd[step]; + + int outX = tileOutX + relOutX; + int outY = tileOutY + relOutY0; + + if (outX < p.yShape.x & outY < p.yShape.y) + *((T*)((char*)p.y + (outX * get_stride(p.yStride.x) + outY * get_stride(p.yStride.y) + mapOfsOut))) = (T)v; + } + } + else if (filterMode == MODE_SUFD || filterMode == MODE_FUFD) + { + // Full downsampling filter. + if (down == 2) + { + // 2-wide. + __syncthreads(); + for (int idx = threadIdx.x * 2; idx < tileOutW * tileOutH; idx += blockDim.x * 2) + { + int relOutX0, relOutY0; + fast_div_mod(relOutX0, relOutY0, idx); + int relUpX0 = relOutX0 * down; + int relUpY0 = relOutY0 * down; + int src0 = relUpY0 * tileUpW + relUpX0; + vec2_t v = InternalType::zero_vec2(); + #pragma unroll + for (int sy = 0; sy < fdSize; sy++) + #pragma unroll + for (int sx = 0; sx < fdSize; sx++) + { + v.x += s_tileUpXY[src0 + 0 + sx + sy * tileUpW] * (scalar_t)c_fd[sx + sy * MAX_FILTER_SIZE]; + v.y += s_tileUpXY[src0 + 2 + sx + sy * tileUpW] * (scalar_t)c_fd[sx + sy * MAX_FILTER_SIZE]; + } + + int outX = tileOutX + relOutX0; + int outY = tileOutY + relOutY0; + if ((uint32_t)outY < p.yShape.y) + { + index_t ofs = outX * get_stride(p.yStride.x) + outY * get_stride(p.yStride.y) + mapOfsOut; + if (outX + 0 < p.yShape.x) *((T*)((char*)p.y + ofs)) = (T)v.x; + if (outX + 1 < p.yShape.x) *((T*)((char*)p.y + ofs + get_stride(p.yStride.x))) = (T)v.y; + } + } + } + else if (down == 1 && !downInline) + { + // Thread per pixel. + __syncthreads(); + for (int idx = threadIdx.x; idx < tileOutW * tileOutH; idx += blockDim.x) + { + int relOutX0, relOutY0; + fast_div_mod(relOutX0, relOutY0, idx); + scalar_t v = s_tileUpXY[idx] * (scalar_t)c_fd[0]; // 1x1 filter. + + int outX = tileOutX + relOutX0; + int outY = tileOutY + relOutY0; + if ((uint32_t)outX < p.yShape.x && (uint32_t)outY < p.yShape.y) + *((T*)((char*)p.y + (outX * get_stride(p.yStride.x) + outY * get_stride(p.yStride.y) + mapOfsOut))) = (T)v; + } + } + } + + if (!enableXrep) + break; + } +} + +//------------------------------------------------------------------------ +// Compute activation function and signs for upsampled data tensor, modifying data tensor in-place. Used for accelerating the generic variant. +// Sign tensor is known to be contiguous, and p.x and p.s have the same z, w dimensions. 64-bit indexing is always used. + +template +static __global__ void filtered_lrelu_act_kernel(filtered_lrelu_act_kernel_params p) +{ + typedef typename InternalType::scalar_t scalar_t; + + // Indexing. + int32_t x = threadIdx.x + blockIdx.x * blockDim.x; + int32_t ymax = signWrite ? p.sShape.y : p.xShape.y; + int32_t qmax = p.xShape.z * p.xShape.w; // Combined minibatch*channel maximum index. + + // Loop to accommodate oversized tensors. + for (int32_t q = blockIdx.z; q < qmax; q += gridDim.z) + for (int32_t y = blockIdx.y; y < ymax; y += gridDim.y) + { + // Extract z and w (channel, minibatch index). + int32_t w = q / p.xShape.z; + int32_t z = q - w * p.xShape.z; + + // Choose behavior based on sign read/write mode. + if (signWrite) + { + // Process value if in p.x. + uint32_t s = 0; + if (x < p.xShape.x && y < p.xShape.y) + { + int64_t ix = x * p.xStride.x + y * p.xStride.y + z * p.xStride.z + w * p.xStride.w; + T* pv = ((T*)p.x) + ix; + scalar_t v = (scalar_t)(*pv); + + // Gain, LReLU, clamp. + v *= p.gain; + if (v < 0.f) + { + v *= p.slope; + s = 1; // Sign. + } + if (fabsf(v) > p.clamp) + { + v = InternalType::clamp(v, p.clamp); + s = 2; // Clamp. + } + + *pv = (T)v; // Write value. + } + + // Coalesce into threads 0 and 16 of warp. + uint32_t m = (threadIdx.x & 16) ? 0xffff0000u : 0x0000ffffu; + s <<= ((threadIdx.x & 15) << 1); // Shift into place. + s |= __shfl_xor_sync(m, s, 1); // Distribute. + s |= __shfl_xor_sync(m, s, 2); + s |= __shfl_xor_sync(m, s, 4); + s |= __shfl_xor_sync(m, s, 8); + + // Write signs if leader and in p.s. + if (!(threadIdx.x & 15) && x < p.sShape.x) // y is always in. + { + uint64_t is = x + p.sShape.x * (y + (int64_t)p.sShape.y * q); // Contiguous. + ((uint32_t*)p.s)[is >> 4] = s; + } + } + else if (signRead) + { + // Process value if in p.x. + if (x < p.xShape.x) // y is always in. + { + int64_t ix = x * p.xStride.x + y * p.xStride.y + z * p.xStride.z + w * p.xStride.w; + T* pv = ((T*)p.x) + ix; + scalar_t v = (scalar_t)(*pv); + v *= p.gain; + + // Apply sign buffer offset. + uint32_t sx = x + p.sOfs.x; + uint32_t sy = y + p.sOfs.y; + + // Read and apply signs if we land inside valid region of sign buffer. + if (sx < p.sShape.x && sy < p.sShape.y) + { + uint64_t is = (sx >> 2) + (p.sShape.x >> 2) * (sy + (uint64_t)p.sShape.y * q); // Contiguous. + unsigned char s = p.s[is]; + s >>= (sx & 3) << 1; // Shift into place. + if (s & 1) // Sign? + v *= p.slope; + if (s & 2) // Clamp? + v = 0.f; + } + + *pv = (T)v; // Write value. + } + } + else + { + // Forward pass with no sign write. Process value if in p.x. + if (x < p.xShape.x) // y is always in. + { + int64_t ix = x * p.xStride.x + y * p.xStride.y + z * p.xStride.z + w * p.xStride.w; + T* pv = ((T*)p.x) + ix; + scalar_t v = (scalar_t)(*pv); + v *= p.gain; + if (v < 0.f) + v *= p.slope; + if (fabsf(v) > p.clamp) + v = InternalType::clamp(v, p.clamp); + *pv = (T)v; // Write value. + } + } + } +} + +template void* choose_filtered_lrelu_act_kernel(void) +{ + return (void*)filtered_lrelu_act_kernel; +} + +//------------------------------------------------------------------------ +// CUDA kernel selection. + +template filtered_lrelu_kernel_spec choose_filtered_lrelu_kernel(const filtered_lrelu_kernel_params& p, int sharedKB) +{ + filtered_lrelu_kernel_spec s = { 0 }; + + // Return the first matching kernel. +#define CASE(SH, U, FU, D, FD, MODE, TW, TH, W, XR, WS) \ + if (sharedKB >= SH) \ + if ((p.fuShape.y == 0 && (MODE == MODE_SUSD || MODE == MODE_SUFD)) || (p.fuShape.y > 0 && (MODE == MODE_FUSD || MODE == MODE_FUFD))) \ + if ((p.fdShape.y == 0 && (MODE == MODE_SUSD || MODE == MODE_FUSD)) || (p.fdShape.y > 0 && (MODE == MODE_SUFD || MODE == MODE_FUFD))) \ + if (p.up == U && p.fuShape.x <= FU && p.fuShape.y <= FU && p.down == D && p.fdShape.x <= FD && p.fdShape.y <= FD) \ + { \ + static_assert((D*TW % 4) == 0, "down * tileWidth must be divisible by 4"); \ + static_assert(FU % U == 0, "upscaling filter size must be multiple of upscaling factor"); \ + static_assert(FD % D == 0, "downscaling filter size must be multiple of downscaling factor"); \ + s.setup = (void*)setup_filters_kernel; \ + s.exec = (void*)filtered_lrelu_kernel; \ + s.tileOut = make_int2(TW, TH); \ + s.numWarps = W; \ + s.xrep = XR; \ + s.dynamicSharedKB = (SH == 48) ? 0 : SH; \ + return s; \ + } + + // Launch parameters for various kernel specializations. + // Small filters must be listed before large filters, otherwise the kernel for larger filter will always match first. + // Kernels that use more shared memory must be listed before those that use less, for the same reason. + + CASE(/*sharedKB*/48, /*up,fu*/1,1, /*down,fd*/1,1, /*mode*/MODE_FUFD, /*tw,th,warps,xrep,wskip*/64, 178, 32, 0, 0) // 1t-upf1-downf1 + CASE(/*sharedKB*/48, /*up,fu*/2,8, /*down,fd*/1,1, /*mode*/MODE_SUFD, /*tw,th,warps,xrep,wskip*/152, 95, 16, 0, 0) // 4t-ups2-downf1 + CASE(/*sharedKB*/48, /*up,fu*/1,1, /*down,fd*/2,8, /*mode*/MODE_FUSD, /*tw,th,warps,xrep,wskip*/56, 22, 16, 0, 0) // 4t-upf1-downs2 + CASE(/*sharedKB*/48, /*up,fu*/2,8, /*down,fd*/2,8, /*mode*/MODE_SUSD, /*tw,th,warps,xrep,wskip*/56, 29, 16, 11, 0) // 4t-ups2-downs2 + CASE(/*sharedKB*/48, /*up,fu*/2,8, /*down,fd*/2,8, /*mode*/MODE_FUSD, /*tw,th,warps,xrep,wskip*/60, 28, 16, 0, 0) // 4t-upf2-downs2 + CASE(/*sharedKB*/48, /*up,fu*/2,8, /*down,fd*/2,8, /*mode*/MODE_SUFD, /*tw,th,warps,xrep,wskip*/56, 28, 16, 0, 0) // 4t-ups2-downf2 + CASE(/*sharedKB*/48, /*up,fu*/4,16, /*down,fd*/2,8, /*mode*/MODE_SUSD, /*tw,th,warps,xrep,wskip*/56, 31, 16, 11, 0) // 4t-ups4-downs2 + CASE(/*sharedKB*/48, /*up,fu*/4,16, /*down,fd*/2,8, /*mode*/MODE_SUFD, /*tw,th,warps,xrep,wskip*/56, 36, 16, 0, 0) // 4t-ups4-downf2 + CASE(/*sharedKB*/48, /*up,fu*/2,8, /*down,fd*/4,16, /*mode*/MODE_SUSD, /*tw,th,warps,xrep,wskip*/16, 22, 16, 12, 0) // 4t-ups2-downs4 + CASE(/*sharedKB*/48, /*up,fu*/2,8, /*down,fd*/4,16, /*mode*/MODE_FUSD, /*tw,th,warps,xrep,wskip*/29, 15, 16, 0, 0) // 4t-upf2-downs4 + CASE(/*sharedKB*/48, /*up,fu*/2,12, /*down,fd*/1,1, /*mode*/MODE_SUFD, /*tw,th,warps,xrep,wskip*/96, 150, 28, 0, 0) // 6t-ups2-downf1 + CASE(/*sharedKB*/48, /*up,fu*/1,1, /*down,fd*/2,12, /*mode*/MODE_FUSD, /*tw,th,warps,xrep,wskip*/32, 35, 24, 0, 0) // 6t-upf1-downs2 + CASE(/*sharedKB*/48, /*up,fu*/2,12, /*down,fd*/2,12, /*mode*/MODE_SUSD, /*tw,th,warps,xrep,wskip*/32, 46, 16, 10, 0) // 6t-ups2-downs2 + CASE(/*sharedKB*/48, /*up,fu*/2,12, /*down,fd*/2,12, /*mode*/MODE_FUSD, /*tw,th,warps,xrep,wskip*/58, 28, 24, 8, 0) // 6t-upf2-downs2 + CASE(/*sharedKB*/48, /*up,fu*/2,12, /*down,fd*/2,12, /*mode*/MODE_SUFD, /*tw,th,warps,xrep,wskip*/52, 28, 16, 0, 0) // 6t-ups2-downf2 + CASE(/*sharedKB*/48, /*up,fu*/4,24, /*down,fd*/2,12, /*mode*/MODE_SUSD, /*tw,th,warps,xrep,wskip*/32, 51, 16, 5, 0) // 6t-ups4-downs2 + CASE(/*sharedKB*/48, /*up,fu*/4,24, /*down,fd*/2,12, /*mode*/MODE_SUFD, /*tw,th,warps,xrep,wskip*/32, 56, 16, 6, 0) // 6t-ups4-downf2 + CASE(/*sharedKB*/48, /*up,fu*/2,12, /*down,fd*/4,24, /*mode*/MODE_SUSD, /*tw,th,warps,xrep,wskip*/16, 18, 16, 12, 0) // 6t-ups2-downs4 + CASE(/*sharedKB*/96, /*up,fu*/2,12, /*down,fd*/4,24, /*mode*/MODE_FUSD, /*tw,th,warps,xrep,wskip*/27, 31, 32, 6, 0) // 6t-upf2-downs4 96kB + CASE(/*sharedKB*/48, /*up,fu*/2,12, /*down,fd*/4,24, /*mode*/MODE_FUSD, /*tw,th,warps,xrep,wskip*/27, 13, 24, 0, 0) // 6t-upf2-downs4 + CASE(/*sharedKB*/48, /*up,fu*/2,16, /*down,fd*/1,1, /*mode*/MODE_SUFD, /*tw,th,warps,xrep,wskip*/148, 89, 24, 0, 0) // 8t-ups2-downf1 + CASE(/*sharedKB*/48, /*up,fu*/1,1, /*down,fd*/2,16, /*mode*/MODE_FUSD, /*tw,th,warps,xrep,wskip*/32, 31, 16, 5, 0) // 8t-upf1-downs2 + CASE(/*sharedKB*/48, /*up,fu*/2,16, /*down,fd*/2,16, /*mode*/MODE_SUSD, /*tw,th,warps,xrep,wskip*/32, 41, 16, 9, 0) // 8t-ups2-downs2 + CASE(/*sharedKB*/48, /*up,fu*/2,16, /*down,fd*/2,16, /*mode*/MODE_FUSD, /*tw,th,warps,xrep,wskip*/56, 26, 24, 0, 0) // 8t-upf2-downs2 + CASE(/*sharedKB*/48, /*up,fu*/2,16, /*down,fd*/2,16, /*mode*/MODE_SUFD, /*tw,th,warps,xrep,wskip*/32, 40, 16, 0, 0) // 8t-ups2-downf2 + CASE(/*sharedKB*/48, /*up,fu*/4,32, /*down,fd*/2,16, /*mode*/MODE_SUSD, /*tw,th,warps,xrep,wskip*/32, 46, 24, 5, 0) // 8t-ups4-downs2 + CASE(/*sharedKB*/48, /*up,fu*/4,32, /*down,fd*/2,16, /*mode*/MODE_SUFD, /*tw,th,warps,xrep,wskip*/32, 50, 16, 0, 0) // 8t-ups4-downf2 + CASE(/*sharedKB*/96, /*up,fu*/2,16, /*down,fd*/4,32, /*mode*/MODE_SUSD, /*tw,th,warps,xrep,wskip*/24, 24, 32, 12, 1) // 8t-ups2-downs4 96kB + CASE(/*sharedKB*/48, /*up,fu*/2,16, /*down,fd*/4,32, /*mode*/MODE_SUSD, /*tw,th,warps,xrep,wskip*/16, 13, 16, 10, 1) // 8t-ups2-downs4 + CASE(/*sharedKB*/96, /*up,fu*/2,16, /*down,fd*/4,32, /*mode*/MODE_FUSD, /*tw,th,warps,xrep,wskip*/25, 28, 28, 4, 0) // 8t-upf2-downs4 96kB + CASE(/*sharedKB*/48, /*up,fu*/2,16, /*down,fd*/4,32, /*mode*/MODE_FUSD, /*tw,th,warps,xrep,wskip*/25, 10, 24, 0, 0) // 8t-upf2-downs4 + + #undef CASE + return s; // No kernel found. +} + +//------------------------------------------------------------------------ diff --git a/torch_utils/ops/filtered_lrelu.h b/torch_utils/ops/filtered_lrelu.h new file mode 100644 index 0000000..2c403e3 --- /dev/null +++ b/torch_utils/ops/filtered_lrelu.h @@ -0,0 +1,90 @@ +// Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + +#include + +//------------------------------------------------------------------------ +// CUDA kernel parameters. + +struct filtered_lrelu_kernel_params +{ + // These parameters decide which kernel to use. + int up; // upsampling ratio (1, 2, 4) + int down; // downsampling ratio (1, 2, 4) + int2 fuShape; // [size, 1] | [size, size] + int2 fdShape; // [size, 1] | [size, size] + + int _dummy; // Alignment. + + // Rest of the parameters. + const void* x; // Input tensor. + void* y; // Output tensor. + const void* b; // Bias tensor. + unsigned char* s; // Sign tensor in/out. NULL if unused. + const float* fu; // Upsampling filter. + const float* fd; // Downsampling filter. + + int2 pad0; // Left/top padding. + float gain; // Additional gain factor. + float slope; // Leaky ReLU slope on negative side. + float clamp; // Clamp after nonlinearity. + int flip; // Filter kernel flip for gradient computation. + + int tilesXdim; // Original number of horizontal output tiles. + int tilesXrep; // Number of horizontal tiles per CTA. + int blockZofs; // Block z offset to support large minibatch, channel dimensions. + + int4 xShape; // [width, height, channel, batch] + int4 yShape; // [width, height, channel, batch] + int2 sShape; // [width, height] - width is in bytes. Contiguous. Zeros if unused. + int2 sOfs; // [ofs_x, ofs_y] - offset between upsampled data and sign tensor. + int swLimit; // Active width of sign tensor in bytes. + + longlong4 xStride; // Strides of all tensors except signs, same component order as shapes. + longlong4 yStride; // + int64_t bStride; // + longlong3 fuStride; // + longlong3 fdStride; // +}; + +struct filtered_lrelu_act_kernel_params +{ + void* x; // Input/output, modified in-place. + unsigned char* s; // Sign tensor in/out. NULL if unused. + + float gain; // Additional gain factor. + float slope; // Leaky ReLU slope on negative side. + float clamp; // Clamp after nonlinearity. + + int4 xShape; // [width, height, channel, batch] + longlong4 xStride; // Input/output tensor strides, same order as in shape. + int2 sShape; // [width, height] - width is in elements. Contiguous. Zeros if unused. + int2 sOfs; // [ofs_x, ofs_y] - offset between upsampled data and sign tensor. +}; + +//------------------------------------------------------------------------ +// CUDA kernel specialization. + +struct filtered_lrelu_kernel_spec +{ + void* setup; // Function for filter kernel setup. + void* exec; // Function for main operation. + int2 tileOut; // Width/height of launch tile. + int numWarps; // Number of warps per thread block, determines launch block size. + int xrep; // For processing multiple horizontal tiles per thread block. + int dynamicSharedKB; // How much dynamic shared memory the exec kernel wants. +}; + +//------------------------------------------------------------------------ +// CUDA kernel selection. + +template filtered_lrelu_kernel_spec choose_filtered_lrelu_kernel(const filtered_lrelu_kernel_params& p, int sharedKB); +template void* choose_filtered_lrelu_act_kernel(void); +template cudaError_t copy_filters(cudaStream_t stream); + +//------------------------------------------------------------------------ diff --git a/torch_utils/ops/filtered_lrelu.py b/torch_utils/ops/filtered_lrelu.py new file mode 100644 index 0000000..6701cd7 --- /dev/null +++ b/torch_utils/ops/filtered_lrelu.py @@ -0,0 +1,274 @@ +# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +import os +import numpy as np +import torch +import warnings + +from .. import custom_ops +from .. import misc +from . import upfirdn2d +from . import bias_act + +#---------------------------------------------------------------------------- + +_plugin = None + +def _init(): + global _plugin + if _plugin is None: + _plugin = custom_ops.get_plugin( + module_name='filtered_lrelu_plugin', + sources=['filtered_lrelu.cpp', 'filtered_lrelu_wr.cu', 'filtered_lrelu_rd.cu', 'filtered_lrelu_ns.cu'], + headers=['filtered_lrelu.h', 'filtered_lrelu.cu'], + source_dir=os.path.dirname(__file__), + extra_cuda_cflags=['--use_fast_math', '--allow-unsupported-compiler'], + ) + return True + +def _get_filter_size(f): + if f is None: + return 1, 1 + assert isinstance(f, torch.Tensor) + assert 1 <= f.ndim <= 2 + return f.shape[-1], f.shape[0] # width, height + +def _parse_padding(padding): + if isinstance(padding, int): + padding = [padding, padding] + assert isinstance(padding, (list, tuple)) + assert all(isinstance(x, (int, np.integer)) for x in padding) + padding = [int(x) for x in padding] + if len(padding) == 2: + px, py = padding + padding = [px, px, py, py] + px0, px1, py0, py1 = padding + return px0, px1, py0, py1 + +#---------------------------------------------------------------------------- + +def filtered_lrelu(x, fu=None, fd=None, b=None, up=1, down=1, padding=0, gain=np.sqrt(2), slope=0.2, clamp=None, flip_filter=False, impl='cuda'): + r"""Filtered leaky ReLU for a batch of 2D images. + + Performs the following sequence of operations for each channel: + + 1. Add channel-specific bias if provided (`b`). + + 2. Upsample the image by inserting N-1 zeros after each pixel (`up`). + + 3. Pad the image with the specified number of zeros on each side (`padding`). + Negative padding corresponds to cropping the image. + + 4. Convolve the image with the specified upsampling FIR filter (`fu`), shrinking it + so that the footprint of all output pixels lies within the input image. + + 5. Multiply each value by the provided gain factor (`gain`). + + 6. Apply leaky ReLU activation function to each value. + + 7. Clamp each value between -clamp and +clamp, if `clamp` parameter is provided. + + 8. Convolve the image with the specified downsampling FIR filter (`fd`), shrinking + it so that the footprint of all output pixels lies within the input image. + + 9. Downsample the image by keeping every Nth pixel (`down`). + + The fused op is considerably more efficient than performing the same calculation + using standard PyTorch ops. It supports gradients of arbitrary order. + + Args: + x: Float32/float16/float64 input tensor of the shape + `[batch_size, num_channels, in_height, in_width]`. + fu: Float32 upsampling FIR filter of the shape + `[filter_height, filter_width]` (non-separable), + `[filter_taps]` (separable), or + `None` (identity). + fd: Float32 downsampling FIR filter of the shape + `[filter_height, filter_width]` (non-separable), + `[filter_taps]` (separable), or + `None` (identity). + b: Bias vector, or `None` to disable. Must be a 1D tensor of the same type + as `x`. The length of vector must must match the channel dimension of `x`. + up: Integer upsampling factor (default: 1). + down: Integer downsampling factor. (default: 1). + padding: Padding with respect to the upsampled image. Can be a single number + or a list/tuple `[x, y]` or `[x_before, x_after, y_before, y_after]` + (default: 0). + gain: Overall scaling factor for signal magnitude (default: sqrt(2)). + slope: Slope on the negative side of leaky ReLU (default: 0.2). + clamp: Maximum magnitude for leaky ReLU output (default: None). + flip_filter: False = convolution, True = correlation (default: False). + impl: Implementation to use. Can be `'ref'` or `'cuda'` (default: `'cuda'`). + + Returns: + Tensor of the shape `[batch_size, num_channels, out_height, out_width]`. + """ + assert isinstance(x, torch.Tensor) + assert impl in ['ref', 'cuda'] + if impl == 'cuda' and x.device.type == 'cuda' and _init(): + return _filtered_lrelu_cuda(up=up, down=down, padding=padding, gain=gain, slope=slope, clamp=clamp, flip_filter=flip_filter).apply(x, fu, fd, b, None, 0, 0) + return _filtered_lrelu_ref(x, fu=fu, fd=fd, b=b, up=up, down=down, padding=padding, gain=gain, slope=slope, clamp=clamp, flip_filter=flip_filter) + +#---------------------------------------------------------------------------- + +@misc.profiled_function +def _filtered_lrelu_ref(x, fu=None, fd=None, b=None, up=1, down=1, padding=0, gain=np.sqrt(2), slope=0.2, clamp=None, flip_filter=False): + """Slow and memory-inefficient reference implementation of `filtered_lrelu()` using + existing `upfirdn2n()` and `bias_act()` ops. + """ + assert isinstance(x, torch.Tensor) and x.ndim == 4 + fu_w, fu_h = _get_filter_size(fu) + fd_w, fd_h = _get_filter_size(fd) + if b is not None: + assert isinstance(b, torch.Tensor) and b.dtype == x.dtype + misc.assert_shape(b, [x.shape[1]]) + assert isinstance(up, int) and up >= 1 + assert isinstance(down, int) and down >= 1 + px0, px1, py0, py1 = _parse_padding(padding) + assert gain == float(gain) and gain > 0 + assert slope == float(slope) and slope >= 0 + assert clamp is None or (clamp == float(clamp) and clamp >= 0) + + # Calculate output size. + batch_size, channels, in_h, in_w = x.shape + in_dtype = x.dtype + out_w = (in_w * up + (px0 + px1) - (fu_w - 1) - (fd_w - 1) + (down - 1)) // down + out_h = (in_h * up + (py0 + py1) - (fu_h - 1) - (fd_h - 1) + (down - 1)) // down + + # Compute using existing ops. + x = bias_act.bias_act(x=x, b=b) # Apply bias. + x = upfirdn2d.upfirdn2d(x=x, f=fu, up=up, padding=[px0, px1, py0, py1], gain=up**2, flip_filter=flip_filter) # Upsample. + x = bias_act.bias_act(x=x, act='lrelu', alpha=slope, gain=gain, clamp=clamp) # Bias, leaky ReLU, clamp. + x = upfirdn2d.upfirdn2d(x=x, f=fd, down=down, flip_filter=flip_filter) # Downsample. + + # Check output shape & dtype. + misc.assert_shape(x, [batch_size, channels, out_h, out_w]) + assert x.dtype == in_dtype + return x + +#---------------------------------------------------------------------------- + +_filtered_lrelu_cuda_cache = dict() + +def _filtered_lrelu_cuda(up=1, down=1, padding=0, gain=np.sqrt(2), slope=0.2, clamp=None, flip_filter=False): + """Fast CUDA implementation of `filtered_lrelu()` using custom ops. + """ + assert isinstance(up, int) and up >= 1 + assert isinstance(down, int) and down >= 1 + px0, px1, py0, py1 = _parse_padding(padding) + assert gain == float(gain) and gain > 0 + gain = float(gain) + assert slope == float(slope) and slope >= 0 + slope = float(slope) + assert clamp is None or (clamp == float(clamp) and clamp >= 0) + clamp = float(clamp if clamp is not None else 'inf') + + # Lookup from cache. + key = (up, down, px0, px1, py0, py1, gain, slope, clamp, flip_filter) + if key in _filtered_lrelu_cuda_cache: + return _filtered_lrelu_cuda_cache[key] + + # Forward op. + class FilteredLReluCuda(torch.autograd.Function): + @staticmethod + def forward(ctx, x, fu, fd, b, si, sx, sy): # pylint: disable=arguments-differ + assert isinstance(x, torch.Tensor) and x.ndim == 4 + + # Replace empty up/downsample kernels with full 1x1 kernels (faster than separable). + if fu is None: + fu = torch.ones([1, 1], dtype=torch.float32, device=x.device) + if fd is None: + fd = torch.ones([1, 1], dtype=torch.float32, device=x.device) + assert 1 <= fu.ndim <= 2 + assert 1 <= fd.ndim <= 2 + + # Replace separable 1x1 kernels with full 1x1 kernels when scale factor is 1. + if up == 1 and fu.ndim == 1 and fu.shape[0] == 1: + fu = fu.square()[None] + if down == 1 and fd.ndim == 1 and fd.shape[0] == 1: + fd = fd.square()[None] + + # Missing sign input tensor. + if si is None: + si = torch.empty([0]) + + # Missing bias tensor. + if b is None: + b = torch.zeros([x.shape[1]], dtype=x.dtype, device=x.device) + + # Construct internal sign tensor only if gradients are needed. + write_signs = (si.numel() == 0) and (x.requires_grad or b.requires_grad) + + # Warn if input storage strides are not in decreasing order due to e.g. channels-last layout. + strides = [x.stride(i) for i in range(x.ndim) if x.size(i) > 1] + if any(a < b for a, b in zip(strides[:-1], strides[1:])): + warnings.warn("low-performance memory layout detected in filtered_lrelu input", RuntimeWarning) + + # Call C++/Cuda plugin if datatype is supported. + if x.dtype in [torch.float16, torch.float32]: + if torch.cuda.current_stream(x.device) != torch.cuda.default_stream(x.device): + warnings.warn("filtered_lrelu called with non-default cuda stream but concurrent execution is not supported", RuntimeWarning) + y, so, return_code = _plugin.filtered_lrelu(x, fu, fd, b, si, up, down, px0, px1, py0, py1, sx, sy, gain, slope, clamp, flip_filter, write_signs) + else: + return_code = -1 + + # No Cuda kernel found? Fall back to generic implementation. Still more memory efficient than the reference implementation because + # only the bit-packed sign tensor is retained for gradient computation. + if return_code < 0: + warnings.warn("filtered_lrelu called with parameters that have no optimized CUDA kernel, using generic fallback", RuntimeWarning) + + y = x.add(b.unsqueeze(-1).unsqueeze(-1)) # Add bias. + y = upfirdn2d.upfirdn2d(x=y, f=fu, up=up, padding=[px0, px1, py0, py1], gain=up**2, flip_filter=flip_filter) # Upsample. + so = _plugin.filtered_lrelu_act_(y, si, sx, sy, gain, slope, clamp, write_signs) # Activation function and sign handling. Modifies y in-place. + y = upfirdn2d.upfirdn2d(x=y, f=fd, down=down, flip_filter=flip_filter) # Downsample. + + # Prepare for gradient computation. + ctx.save_for_backward(fu, fd, (si if si.numel() else so)) + ctx.x_shape = x.shape + ctx.y_shape = y.shape + ctx.s_ofs = sx, sy + return y + + @staticmethod + def backward(ctx, dy): # pylint: disable=arguments-differ + fu, fd, si = ctx.saved_tensors + _, _, xh, xw = ctx.x_shape + _, _, yh, yw = ctx.y_shape + sx, sy = ctx.s_ofs + dx = None # 0 + dfu = None; assert not ctx.needs_input_grad[1] + dfd = None; assert not ctx.needs_input_grad[2] + db = None # 3 + dsi = None; assert not ctx.needs_input_grad[4] + dsx = None; assert not ctx.needs_input_grad[5] + dsy = None; assert not ctx.needs_input_grad[6] + + if ctx.needs_input_grad[0] or ctx.needs_input_grad[3]: + pp = [ + (fu.shape[-1] - 1) + (fd.shape[-1] - 1) - px0, + xw * up - yw * down + px0 - (up - 1), + (fu.shape[0] - 1) + (fd.shape[0] - 1) - py0, + xh * up - yh * down + py0 - (up - 1), + ] + gg = gain * (up ** 2) / (down ** 2) + ff = (not flip_filter) + sx = sx - (fu.shape[-1] - 1) + px0 + sy = sy - (fu.shape[0] - 1) + py0 + dx = _filtered_lrelu_cuda(up=down, down=up, padding=pp, gain=gg, slope=slope, clamp=None, flip_filter=ff).apply(dy, fd, fu, None, si, sx, sy) + + if ctx.needs_input_grad[3]: + db = dx.sum([0, 2, 3]) + + return dx, dfu, dfd, db, dsi, dsx, dsy + + # Add to cache. + _filtered_lrelu_cuda_cache[key] = FilteredLReluCuda + return FilteredLReluCuda + +#---------------------------------------------------------------------------- diff --git a/torch_utils/ops/filtered_lrelu_ns.cu b/torch_utils/ops/filtered_lrelu_ns.cu new file mode 100644 index 0000000..ef5d948 --- /dev/null +++ b/torch_utils/ops/filtered_lrelu_ns.cu @@ -0,0 +1,27 @@ +// Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + +#include "filtered_lrelu.cu" + +// Template/kernel specializations for no signs mode (no gradients required). + +// Full op, 32-bit indexing. +template filtered_lrelu_kernel_spec choose_filtered_lrelu_kernel(const filtered_lrelu_kernel_params& p, int sharedKB); +template filtered_lrelu_kernel_spec choose_filtered_lrelu_kernel(const filtered_lrelu_kernel_params& p, int sharedKB); + +// Full op, 64-bit indexing. +template filtered_lrelu_kernel_spec choose_filtered_lrelu_kernel(const filtered_lrelu_kernel_params& p, int sharedKB); +template filtered_lrelu_kernel_spec choose_filtered_lrelu_kernel(const filtered_lrelu_kernel_params& p, int sharedKB); + +// Activation/signs only for generic variant. 64-bit indexing. +template void* choose_filtered_lrelu_act_kernel(void); +template void* choose_filtered_lrelu_act_kernel(void); +template void* choose_filtered_lrelu_act_kernel(void); + +// Copy filters to constant memory. +template cudaError_t copy_filters(cudaStream_t stream); diff --git a/torch_utils/ops/filtered_lrelu_rd.cu b/torch_utils/ops/filtered_lrelu_rd.cu new file mode 100644 index 0000000..9683478 --- /dev/null +++ b/torch_utils/ops/filtered_lrelu_rd.cu @@ -0,0 +1,27 @@ +// Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + +#include "filtered_lrelu.cu" + +// Template/kernel specializations for sign read mode. + +// Full op, 32-bit indexing. +template filtered_lrelu_kernel_spec choose_filtered_lrelu_kernel(const filtered_lrelu_kernel_params& p, int sharedKB); +template filtered_lrelu_kernel_spec choose_filtered_lrelu_kernel(const filtered_lrelu_kernel_params& p, int sharedKB); + +// Full op, 64-bit indexing. +template filtered_lrelu_kernel_spec choose_filtered_lrelu_kernel(const filtered_lrelu_kernel_params& p, int sharedKB); +template filtered_lrelu_kernel_spec choose_filtered_lrelu_kernel(const filtered_lrelu_kernel_params& p, int sharedKB); + +// Activation/signs only for generic variant. 64-bit indexing. +template void* choose_filtered_lrelu_act_kernel(void); +template void* choose_filtered_lrelu_act_kernel(void); +template void* choose_filtered_lrelu_act_kernel(void); + +// Copy filters to constant memory. +template cudaError_t copy_filters(cudaStream_t stream); diff --git a/torch_utils/ops/filtered_lrelu_wr.cu b/torch_utils/ops/filtered_lrelu_wr.cu new file mode 100644 index 0000000..a4c6a24 --- /dev/null +++ b/torch_utils/ops/filtered_lrelu_wr.cu @@ -0,0 +1,27 @@ +// Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + +#include "filtered_lrelu.cu" + +// Template/kernel specializations for sign write mode. + +// Full op, 32-bit indexing. +template filtered_lrelu_kernel_spec choose_filtered_lrelu_kernel(const filtered_lrelu_kernel_params& p, int sharedKB); +template filtered_lrelu_kernel_spec choose_filtered_lrelu_kernel(const filtered_lrelu_kernel_params& p, int sharedKB); + +// Full op, 64-bit indexing. +template filtered_lrelu_kernel_spec choose_filtered_lrelu_kernel(const filtered_lrelu_kernel_params& p, int sharedKB); +template filtered_lrelu_kernel_spec choose_filtered_lrelu_kernel(const filtered_lrelu_kernel_params& p, int sharedKB); + +// Activation/signs only for generic variant. 64-bit indexing. +template void* choose_filtered_lrelu_act_kernel(void); +template void* choose_filtered_lrelu_act_kernel(void); +template void* choose_filtered_lrelu_act_kernel(void); + +// Copy filters to constant memory. +template cudaError_t copy_filters(cudaStream_t stream); diff --git a/torch_utils/ops/fma.py b/torch_utils/ops/fma.py new file mode 100644 index 0000000..51a45df --- /dev/null +++ b/torch_utils/ops/fma.py @@ -0,0 +1,60 @@ +# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +"""Fused multiply-add, with slightly faster gradients than `torch.addcmul()`.""" + +import torch + +#---------------------------------------------------------------------------- + +def fma(a, b, c): # => a * b + c + return _FusedMultiplyAdd.apply(a, b, c) + +#---------------------------------------------------------------------------- + +class _FusedMultiplyAdd(torch.autograd.Function): # a * b + c + @staticmethod + def forward(ctx, a, b, c): # pylint: disable=arguments-differ + out = torch.addcmul(c, a, b) + ctx.save_for_backward(a, b) + ctx.c_shape = c.shape + return out + + @staticmethod + def backward(ctx, dout): # pylint: disable=arguments-differ + a, b = ctx.saved_tensors + c_shape = ctx.c_shape + da = None + db = None + dc = None + + if ctx.needs_input_grad[0]: + da = _unbroadcast(dout * b, a.shape) + + if ctx.needs_input_grad[1]: + db = _unbroadcast(dout * a, b.shape) + + if ctx.needs_input_grad[2]: + dc = _unbroadcast(dout, c_shape) + + return da, db, dc + +#---------------------------------------------------------------------------- + +def _unbroadcast(x, shape): + extra_dims = x.ndim - len(shape) + assert extra_dims >= 0 + dim = [i for i in range(x.ndim) if x.shape[i] > 1 and (i < extra_dims or shape[i - extra_dims] == 1)] + if len(dim): + x = x.sum(dim=dim, keepdim=True) + if extra_dims: + x = x.reshape(-1, *x.shape[extra_dims+1:]) + assert x.shape == shape + return x + +#---------------------------------------------------------------------------- diff --git a/torch_utils/ops/grid_sample_gradfix.py b/torch_utils/ops/grid_sample_gradfix.py new file mode 100644 index 0000000..017f03a --- /dev/null +++ b/torch_utils/ops/grid_sample_gradfix.py @@ -0,0 +1,86 @@ +# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +"""Custom replacement for `torch.nn.functional.grid_sample` that +supports arbitrarily high order gradients between the input and output. +Only works on 2D images and assumes +`mode='bilinear'`, `padding_mode='zeros'`, `align_corners=False`.""" + +import torch +from pkg_resources import parse_version + +# pylint: disable=redefined-builtin +# pylint: disable=arguments-differ +# pylint: disable=protected-access + +#---------------------------------------------------------------------------- + +enabled = False # Enable the custom op by setting this to true. +_use_pytorch_1_11_api = parse_version(torch.__version__) >= parse_version('1.11.0a') # Allow prerelease builds of 1.11 +_use_pytorch_1_12_api = parse_version(torch.__version__) >= parse_version('1.12.0a') # Allow prerelease builds of 1.12 + +#---------------------------------------------------------------------------- + +def grid_sample(input, grid): + if _should_use_custom_op(): + return _GridSample2dForward.apply(input, grid) + return torch.nn.functional.grid_sample(input=input, grid=grid, mode='bilinear', padding_mode='zeros', align_corners=False) + +#---------------------------------------------------------------------------- + +def _should_use_custom_op(): + return enabled + +#---------------------------------------------------------------------------- + +class _GridSample2dForward(torch.autograd.Function): + @staticmethod + def forward(ctx, input, grid): + assert input.ndim == 4 + assert grid.ndim == 4 + output = torch.nn.functional.grid_sample(input=input, grid=grid, mode='bilinear', padding_mode='zeros', align_corners=False) + ctx.save_for_backward(input, grid) + return output + + @staticmethod + def backward(ctx, grad_output): + input, grid = ctx.saved_tensors + grad_input, grad_grid = _GridSample2dBackward.apply(grad_output, input, grid) + return grad_input, grad_grid + +#---------------------------------------------------------------------------- + +class _GridSample2dBackward(torch.autograd.Function): + @staticmethod + def forward(ctx, grad_output, input, grid): + op = torch._C._jit_get_operation('aten::grid_sampler_2d_backward') + if _use_pytorch_1_12_api: + op = op[0] + if _use_pytorch_1_11_api: + output_mask = (ctx.needs_input_grad[1], ctx.needs_input_grad[2]) + grad_input, grad_grid = op(grad_output, input, grid, 0, 0, False, output_mask) + else: + grad_input, grad_grid = op(grad_output, input, grid, 0, 0, False) + ctx.save_for_backward(grid) + return grad_input, grad_grid + + @staticmethod + def backward(ctx, grad2_grad_input, grad2_grad_grid): + _ = grad2_grad_grid # unused + grid, = ctx.saved_tensors + grad2_grad_output = None + grad2_input = None + grad2_grid = None + + if ctx.needs_input_grad[0]: + grad2_grad_output = _GridSample2dForward.apply(grad2_grad_input, grid) + + assert not ctx.needs_input_grad[2] + return grad2_grad_output, grad2_input, grad2_grid + +#---------------------------------------------------------------------------- diff --git a/torch_utils/ops/upfirdn2d.cpp b/torch_utils/ops/upfirdn2d.cpp new file mode 100644 index 0000000..44fa337 --- /dev/null +++ b/torch_utils/ops/upfirdn2d.cpp @@ -0,0 +1,107 @@ +// Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + +#include +#include +#include +#include "upfirdn2d.h" + +//------------------------------------------------------------------------ + +static torch::Tensor upfirdn2d(torch::Tensor x, torch::Tensor f, int upx, int upy, int downx, int downy, int padx0, int padx1, int pady0, int pady1, bool flip, float gain) +{ + // Validate arguments. + TORCH_CHECK(x.is_cuda(), "x must reside on CUDA device"); + TORCH_CHECK(f.device() == x.device(), "f must reside on the same device as x"); + TORCH_CHECK(f.dtype() == torch::kFloat, "f must be float32"); + TORCH_CHECK(x.numel() <= INT_MAX, "x is too large"); + TORCH_CHECK(f.numel() <= INT_MAX, "f is too large"); + TORCH_CHECK(x.numel() > 0, "x has zero size"); + TORCH_CHECK(f.numel() > 0, "f has zero size"); + TORCH_CHECK(x.dim() == 4, "x must be rank 4"); + TORCH_CHECK(f.dim() == 2, "f must be rank 2"); + TORCH_CHECK((x.size(0)-1)*x.stride(0) + (x.size(1)-1)*x.stride(1) + (x.size(2)-1)*x.stride(2) + (x.size(3)-1)*x.stride(3) <= INT_MAX, "x memory footprint is too large"); + TORCH_CHECK(f.size(0) >= 1 && f.size(1) >= 1, "f must be at least 1x1"); + TORCH_CHECK(upx >= 1 && upy >= 1, "upsampling factor must be at least 1"); + TORCH_CHECK(downx >= 1 && downy >= 1, "downsampling factor must be at least 1"); + + // Create output tensor. + const at::cuda::OptionalCUDAGuard device_guard(device_of(x)); + int outW = ((int)x.size(3) * upx + padx0 + padx1 - (int)f.size(1) + downx) / downx; + int outH = ((int)x.size(2) * upy + pady0 + pady1 - (int)f.size(0) + downy) / downy; + TORCH_CHECK(outW >= 1 && outH >= 1, "output must be at least 1x1"); + torch::Tensor y = torch::empty({x.size(0), x.size(1), outH, outW}, x.options(), x.suggest_memory_format()); + TORCH_CHECK(y.numel() <= INT_MAX, "output is too large"); + TORCH_CHECK((y.size(0)-1)*y.stride(0) + (y.size(1)-1)*y.stride(1) + (y.size(2)-1)*y.stride(2) + (y.size(3)-1)*y.stride(3) <= INT_MAX, "output memory footprint is too large"); + + // Initialize CUDA kernel parameters. + upfirdn2d_kernel_params p; + p.x = x.data_ptr(); + p.f = f.data_ptr(); + p.y = y.data_ptr(); + p.up = make_int2(upx, upy); + p.down = make_int2(downx, downy); + p.pad0 = make_int2(padx0, pady0); + p.flip = (flip) ? 1 : 0; + p.gain = gain; + p.inSize = make_int4((int)x.size(3), (int)x.size(2), (int)x.size(1), (int)x.size(0)); + p.inStride = make_int4((int)x.stride(3), (int)x.stride(2), (int)x.stride(1), (int)x.stride(0)); + p.filterSize = make_int2((int)f.size(1), (int)f.size(0)); + p.filterStride = make_int2((int)f.stride(1), (int)f.stride(0)); + p.outSize = make_int4((int)y.size(3), (int)y.size(2), (int)y.size(1), (int)y.size(0)); + p.outStride = make_int4((int)y.stride(3), (int)y.stride(2), (int)y.stride(1), (int)y.stride(0)); + p.sizeMajor = (p.inStride.z == 1) ? p.inSize.w : p.inSize.w * p.inSize.z; + p.sizeMinor = (p.inStride.z == 1) ? p.inSize.z : 1; + + // Choose CUDA kernel. + upfirdn2d_kernel_spec spec; + AT_DISPATCH_FLOATING_TYPES_AND_HALF(x.scalar_type(), "upfirdn2d_cuda", [&] + { + spec = choose_upfirdn2d_kernel(p); + }); + + // Set looping options. + p.loopMajor = (p.sizeMajor - 1) / 16384 + 1; + p.loopMinor = spec.loopMinor; + p.loopX = spec.loopX; + p.launchMinor = (p.sizeMinor - 1) / p.loopMinor + 1; + p.launchMajor = (p.sizeMajor - 1) / p.loopMajor + 1; + + // Compute grid size. + dim3 blockSize, gridSize; + if (spec.tileOutW < 0) // large + { + blockSize = dim3(4, 32, 1); + gridSize = dim3( + ((p.outSize.y - 1) / blockSize.x + 1) * p.launchMinor, + (p.outSize.x - 1) / (blockSize.y * p.loopX) + 1, + p.launchMajor); + } + else // small + { + blockSize = dim3(256, 1, 1); + gridSize = dim3( + ((p.outSize.y - 1) / spec.tileOutH + 1) * p.launchMinor, + (p.outSize.x - 1) / (spec.tileOutW * p.loopX) + 1, + p.launchMajor); + } + + // Launch CUDA kernel. + void* args[] = {&p}; + AT_CUDA_CHECK(cudaLaunchKernel(spec.kernel, gridSize, blockSize, args, 0, at::cuda::getCurrentCUDAStream())); + return y; +} + +//------------------------------------------------------------------------ + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) +{ + m.def("upfirdn2d", &upfirdn2d); +} + +//------------------------------------------------------------------------ diff --git a/torch_utils/ops/upfirdn2d.cu b/torch_utils/ops/upfirdn2d.cu new file mode 100644 index 0000000..3a33e31 --- /dev/null +++ b/torch_utils/ops/upfirdn2d.cu @@ -0,0 +1,384 @@ +// Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + +#include +#include "upfirdn2d.h" + +//------------------------------------------------------------------------ +// Helpers. + +template struct InternalType; +template <> struct InternalType { typedef double scalar_t; }; +template <> struct InternalType { typedef float scalar_t; }; +template <> struct InternalType { typedef float scalar_t; }; + +static __device__ __forceinline__ int floor_div(int a, int b) +{ + int t = 1 - a / b; + return (a + t * b) / b - t; +} + +//------------------------------------------------------------------------ +// Generic CUDA implementation for large filters. + +template static __global__ void upfirdn2d_kernel_large(upfirdn2d_kernel_params p) +{ + typedef typename InternalType::scalar_t scalar_t; + + // Calculate thread index. + int minorBase = blockIdx.x * blockDim.x + threadIdx.x; + int outY = minorBase / p.launchMinor; + minorBase -= outY * p.launchMinor; + int outXBase = blockIdx.y * p.loopX * blockDim.y + threadIdx.y; + int majorBase = blockIdx.z * p.loopMajor; + if (outXBase >= p.outSize.x | outY >= p.outSize.y | majorBase >= p.sizeMajor) + return; + + // Setup Y receptive field. + int midY = outY * p.down.y + p.up.y - 1 - p.pad0.y; + int inY = min(max(floor_div(midY, p.up.y), 0), p.inSize.y); + int h = min(max(floor_div(midY + p.filterSize.y, p.up.y), 0), p.inSize.y) - inY; + int filterY = midY + p.filterSize.y - (inY + 1) * p.up.y; + if (p.flip) + filterY = p.filterSize.y - 1 - filterY; + + // Loop over major, minor, and X. + for (int majorIdx = 0, major = majorBase; majorIdx < p.loopMajor & major < p.sizeMajor; majorIdx++, major++) + for (int minorIdx = 0, minor = minorBase; minorIdx < p.loopMinor & minor < p.sizeMinor; minorIdx++, minor += p.launchMinor) + { + int nc = major * p.sizeMinor + minor; + int n = nc / p.inSize.z; + int c = nc - n * p.inSize.z; + for (int loopX = 0, outX = outXBase; loopX < p.loopX & outX < p.outSize.x; loopX++, outX += blockDim.y) + { + // Setup X receptive field. + int midX = outX * p.down.x + p.up.x - 1 - p.pad0.x; + int inX = min(max(floor_div(midX, p.up.x), 0), p.inSize.x); + int w = min(max(floor_div(midX + p.filterSize.x, p.up.x), 0), p.inSize.x) - inX; + int filterX = midX + p.filterSize.x - (inX + 1) * p.up.x; + if (p.flip) + filterX = p.filterSize.x - 1 - filterX; + + // Initialize pointers. + const T* xp = &((const T*)p.x)[inX * p.inStride.x + inY * p.inStride.y + c * p.inStride.z + n * p.inStride.w]; + const float* fp = &p.f[filterX * p.filterStride.x + filterY * p.filterStride.y]; + int filterStepX = ((p.flip) ? p.up.x : -p.up.x) * p.filterStride.x; + int filterStepY = ((p.flip) ? p.up.y : -p.up.y) * p.filterStride.y; + + // Inner loop. + scalar_t v = 0; + for (int y = 0; y < h; y++) + { + for (int x = 0; x < w; x++) + { + v += (scalar_t)(*xp) * (scalar_t)(*fp); + xp += p.inStride.x; + fp += filterStepX; + } + xp += p.inStride.y - w * p.inStride.x; + fp += filterStepY - w * filterStepX; + } + + // Store result. + v *= p.gain; + ((T*)p.y)[outX * p.outStride.x + outY * p.outStride.y + c * p.outStride.z + n * p.outStride.w] = (T)v; + } + } +} + +//------------------------------------------------------------------------ +// Specialized CUDA implementation for small filters. + +template +static __global__ void upfirdn2d_kernel_small(upfirdn2d_kernel_params p) +{ + typedef typename InternalType::scalar_t scalar_t; + const int tileInW = ((tileOutW - 1) * downx + filterW - 1) / upx + 1; + const int tileInH = ((tileOutH - 1) * downy + filterH - 1) / upy + 1; + __shared__ volatile scalar_t sf[filterH][filterW]; + __shared__ volatile scalar_t sx[tileInH][tileInW][loopMinor]; + + // Calculate tile index. + int minorBase = blockIdx.x; + int tileOutY = minorBase / p.launchMinor; + minorBase -= tileOutY * p.launchMinor; + minorBase *= loopMinor; + tileOutY *= tileOutH; + int tileOutXBase = blockIdx.y * p.loopX * tileOutW; + int majorBase = blockIdx.z * p.loopMajor; + if (tileOutXBase >= p.outSize.x | tileOutY >= p.outSize.y | majorBase >= p.sizeMajor) + return; + + // Load filter (flipped). + for (int tapIdx = threadIdx.x; tapIdx < filterH * filterW; tapIdx += blockDim.x) + { + int fy = tapIdx / filterW; + int fx = tapIdx - fy * filterW; + scalar_t v = 0; + if (fx < p.filterSize.x & fy < p.filterSize.y) + { + int ffx = (p.flip) ? fx : p.filterSize.x - 1 - fx; + int ffy = (p.flip) ? fy : p.filterSize.y - 1 - fy; + v = (scalar_t)p.f[ffx * p.filterStride.x + ffy * p.filterStride.y]; + } + sf[fy][fx] = v; + } + + // Loop over major and X. + for (int majorIdx = 0, major = majorBase; majorIdx < p.loopMajor & major < p.sizeMajor; majorIdx++, major++) + { + int baseNC = major * p.sizeMinor + minorBase; + int n = baseNC / p.inSize.z; + int baseC = baseNC - n * p.inSize.z; + for (int loopX = 0, tileOutX = tileOutXBase; loopX < p.loopX & tileOutX < p.outSize.x; loopX++, tileOutX += tileOutW) + { + // Load input pixels. + int tileMidX = tileOutX * downx + upx - 1 - p.pad0.x; + int tileMidY = tileOutY * downy + upy - 1 - p.pad0.y; + int tileInX = floor_div(tileMidX, upx); + int tileInY = floor_div(tileMidY, upy); + __syncthreads(); + for (int inIdx = threadIdx.x; inIdx < tileInH * tileInW * loopMinor; inIdx += blockDim.x) + { + int relC = inIdx; + int relInX = relC / loopMinor; + int relInY = relInX / tileInW; + relC -= relInX * loopMinor; + relInX -= relInY * tileInW; + int c = baseC + relC; + int inX = tileInX + relInX; + int inY = tileInY + relInY; + scalar_t v = 0; + if (inX >= 0 & inY >= 0 & inX < p.inSize.x & inY < p.inSize.y & c < p.inSize.z) + v = (scalar_t)((const T*)p.x)[inX * p.inStride.x + inY * p.inStride.y + c * p.inStride.z + n * p.inStride.w]; + sx[relInY][relInX][relC] = v; + } + + // Loop over output pixels. + __syncthreads(); + for (int outIdx = threadIdx.x; outIdx < tileOutH * tileOutW * loopMinor; outIdx += blockDim.x) + { + int relC = outIdx; + int relOutX = relC / loopMinor; + int relOutY = relOutX / tileOutW; + relC -= relOutX * loopMinor; + relOutX -= relOutY * tileOutW; + int c = baseC + relC; + int outX = tileOutX + relOutX; + int outY = tileOutY + relOutY; + + // Setup receptive field. + int midX = tileMidX + relOutX * downx; + int midY = tileMidY + relOutY * downy; + int inX = floor_div(midX, upx); + int inY = floor_div(midY, upy); + int relInX = inX - tileInX; + int relInY = inY - tileInY; + int filterX = (inX + 1) * upx - midX - 1; // flipped + int filterY = (inY + 1) * upy - midY - 1; // flipped + + // Inner loop. + if (outX < p.outSize.x & outY < p.outSize.y & c < p.outSize.z) + { + scalar_t v = 0; + #pragma unroll + for (int y = 0; y < filterH / upy; y++) + #pragma unroll + for (int x = 0; x < filterW / upx; x++) + v += sx[relInY + y][relInX + x][relC] * sf[filterY + y * upy][filterX + x * upx]; + v *= p.gain; + ((T*)p.y)[outX * p.outStride.x + outY * p.outStride.y + c * p.outStride.z + n * p.outStride.w] = (T)v; + } + } + } + } +} + +//------------------------------------------------------------------------ +// CUDA kernel selection. + +template upfirdn2d_kernel_spec choose_upfirdn2d_kernel(const upfirdn2d_kernel_params& p) +{ + int s = p.inStride.z, fx = p.filterSize.x, fy = p.filterSize.y; + upfirdn2d_kernel_spec spec = {(void*)upfirdn2d_kernel_large, -1,-1,1, 4}; // contiguous + if (s == 1) spec = {(void*)upfirdn2d_kernel_large, -1,-1,4, 1}; // channels_last + + // No up/downsampling. + if (p.up.x == 1 && p.up.y == 1 && p.down.x == 1 && p.down.y == 1) + { + // contiguous + if (s != 1 && fx <= 24 && fy <= 24) spec = {(void*)upfirdn2d_kernel_small, 64,32,1, 1}; + if (s != 1 && fx <= 16 && fy <= 16) spec = {(void*)upfirdn2d_kernel_small, 64,32,1, 1}; + if (s != 1 && fx <= 7 && fy <= 7 ) spec = {(void*)upfirdn2d_kernel_small, 64,16,1, 1}; + if (s != 1 && fx <= 6 && fy <= 6 ) spec = {(void*)upfirdn2d_kernel_small, 64,16,1, 1}; + if (s != 1 && fx <= 5 && fy <= 5 ) spec = {(void*)upfirdn2d_kernel_small, 64,16,1, 1}; + if (s != 1 && fx <= 4 && fy <= 4 ) spec = {(void*)upfirdn2d_kernel_small, 64,16,1, 1}; + if (s != 1 && fx <= 3 && fy <= 3 ) spec = {(void*)upfirdn2d_kernel_small, 64,16,1, 1}; + if (s != 1 && fx <= 24 && fy <= 1 ) spec = {(void*)upfirdn2d_kernel_small, 128,8,1, 1}; + if (s != 1 && fx <= 16 && fy <= 1 ) spec = {(void*)upfirdn2d_kernel_small, 128,8,1, 1}; + if (s != 1 && fx <= 8 && fy <= 1 ) spec = {(void*)upfirdn2d_kernel_small, 128,8,1, 1}; + if (s != 1 && fx <= 1 && fy <= 24) spec = {(void*)upfirdn2d_kernel_small, 32,32,1, 1}; + if (s != 1 && fx <= 1 && fy <= 16) spec = {(void*)upfirdn2d_kernel_small, 32,32,1, 1}; + if (s != 1 && fx <= 1 && fy <= 8 ) spec = {(void*)upfirdn2d_kernel_small, 32,32,1, 1}; + // channels_last + if (s == 1 && fx <= 24 && fy <= 24) spec = {(void*)upfirdn2d_kernel_small, 32,32,1, 1}; + if (s == 1 && fx <= 16 && fy <= 16) spec = {(void*)upfirdn2d_kernel_small, 32,32,1, 1}; + if (s == 1 && fx <= 7 && fy <= 7 ) spec = {(void*)upfirdn2d_kernel_small, 16,16,8, 1}; + if (s == 1 && fx <= 6 && fy <= 6 ) spec = {(void*)upfirdn2d_kernel_small, 16,16,8, 1}; + if (s == 1 && fx <= 5 && fy <= 5 ) spec = {(void*)upfirdn2d_kernel_small, 16,16,8, 1}; + if (s == 1 && fx <= 4 && fy <= 4 ) spec = {(void*)upfirdn2d_kernel_small, 16,16,8, 1}; + if (s == 1 && fx <= 3 && fy <= 3 ) spec = {(void*)upfirdn2d_kernel_small, 16,16,8, 1}; + if (s == 1 && fx <= 24 && fy <= 1 ) spec = {(void*)upfirdn2d_kernel_small, 128,1,16, 1}; + if (s == 1 && fx <= 16 && fy <= 1 ) spec = {(void*)upfirdn2d_kernel_small, 128,1,16, 1}; + if (s == 1 && fx <= 8 && fy <= 1 ) spec = {(void*)upfirdn2d_kernel_small, 128,1,16, 1}; + if (s == 1 && fx <= 1 && fy <= 24) spec = {(void*)upfirdn2d_kernel_small, 1,128,16, 1}; + if (s == 1 && fx <= 1 && fy <= 16) spec = {(void*)upfirdn2d_kernel_small, 1,128,16, 1}; + if (s == 1 && fx <= 1 && fy <= 8 ) spec = {(void*)upfirdn2d_kernel_small, 1,128,16, 1}; + } + + // 2x upsampling. + if (p.up.x == 2 && p.up.y == 2 && p.down.x == 1 && p.down.y == 1) + { + // contiguous + if (s != 1 && fx <= 24 && fy <= 24) spec = {(void*)upfirdn2d_kernel_small, 64,32,1, 1}; + if (s != 1 && fx <= 16 && fy <= 16) spec = {(void*)upfirdn2d_kernel_small, 64,32,1, 1}; + if (s != 1 && fx <= 8 && fy <= 8 ) spec = {(void*)upfirdn2d_kernel_small, 64,16,1, 1}; + if (s != 1 && fx <= 6 && fy <= 6 ) spec = {(void*)upfirdn2d_kernel_small, 64,16,1, 1}; + if (s != 1 && fx <= 4 && fy <= 4 ) spec = {(void*)upfirdn2d_kernel_small, 64,16,1, 1}; + if (s != 1 && fx <= 2 && fy <= 2 ) spec = {(void*)upfirdn2d_kernel_small, 64,16,1, 1}; + // channels_last + if (s == 1 && fx <= 24 && fy <= 24) spec = {(void*)upfirdn2d_kernel_small, 32,32,1, 1}; + if (s == 1 && fx <= 16 && fy <= 16) spec = {(void*)upfirdn2d_kernel_small, 32,32,1, 1}; + if (s == 1 && fx <= 8 && fy <= 8 ) spec = {(void*)upfirdn2d_kernel_small, 16,16,8, 1}; + if (s == 1 && fx <= 6 && fy <= 6 ) spec = {(void*)upfirdn2d_kernel_small, 16,16,8, 1}; + if (s == 1 && fx <= 4 && fy <= 4 ) spec = {(void*)upfirdn2d_kernel_small, 16,16,8, 1}; + if (s == 1 && fx <= 2 && fy <= 2 ) spec = {(void*)upfirdn2d_kernel_small, 16,16,8, 1}; + } + if (p.up.x == 2 && p.up.y == 1 && p.down.x == 1 && p.down.y == 1) + { + // contiguous + if (s != 1 && fx <= 24 && fy <= 1) spec = {(void*)upfirdn2d_kernel_small, 128,8,1, 1}; + if (s != 1 && fx <= 16 && fy <= 1) spec = {(void*)upfirdn2d_kernel_small, 128,8,1, 1}; + if (s != 1 && fx <= 8 && fy <= 1) spec = {(void*)upfirdn2d_kernel_small, 128,8,1, 1}; + // channels_last + if (s == 1 && fx <= 24 && fy <= 1) spec = {(void*)upfirdn2d_kernel_small, 128,1,16, 1}; + if (s == 1 && fx <= 16 && fy <= 1) spec = {(void*)upfirdn2d_kernel_small, 128,1,16, 1}; + if (s == 1 && fx <= 8 && fy <= 1) spec = {(void*)upfirdn2d_kernel_small, 128,1,16, 1}; + } + if (p.up.x == 1 && p.up.y == 2 && p.down.x == 1 && p.down.y == 1) + { + // contiguous + if (s != 1 && fx <= 1 && fy <= 24) spec = {(void*)upfirdn2d_kernel_small, 32,32,1, 1}; + if (s != 1 && fx <= 1 && fy <= 16) spec = {(void*)upfirdn2d_kernel_small, 32,32,1, 1}; + if (s != 1 && fx <= 1 && fy <= 8 ) spec = {(void*)upfirdn2d_kernel_small, 32,32,1, 1}; + // channels_last + if (s == 1 && fx <= 1 && fy <= 24) spec = {(void*)upfirdn2d_kernel_small, 1,128,16, 1}; + if (s == 1 && fx <= 1 && fy <= 16) spec = {(void*)upfirdn2d_kernel_small, 1,128,16, 1}; + if (s == 1 && fx <= 1 && fy <= 8 ) spec = {(void*)upfirdn2d_kernel_small, 1,128,16, 1}; + } + + // 2x downsampling. + if (p.up.x == 1 && p.up.y == 1 && p.down.x == 2 && p.down.y == 2) + { + // contiguous + if (s != 1 && fx <= 24 && fy <= 24) spec = {(void*)upfirdn2d_kernel_small, 32,16,1, 1}; + if (s != 1 && fx <= 16 && fy <= 16) spec = {(void*)upfirdn2d_kernel_small, 32,16,1, 1}; + if (s != 1 && fx <= 8 && fy <= 8 ) spec = {(void*)upfirdn2d_kernel_small, 32,8,1, 1}; + if (s != 1 && fx <= 6 && fy <= 6 ) spec = {(void*)upfirdn2d_kernel_small, 32,8,1, 1}; + if (s != 1 && fx <= 4 && fy <= 4 ) spec = {(void*)upfirdn2d_kernel_small, 32,8,1, 1}; + if (s != 1 && fx <= 2 && fy <= 2 ) spec = {(void*)upfirdn2d_kernel_small, 32,8,1, 1}; + // channels_last + if (s == 1 && fx <= 24 && fy <= 24) spec = {(void*)upfirdn2d_kernel_small, 16,16,1, 1}; + if (s == 1 && fx <= 16 && fy <= 16) spec = {(void*)upfirdn2d_kernel_small, 16,16,1, 1}; + if (s == 1 && fx <= 8 && fy <= 8 ) spec = {(void*)upfirdn2d_kernel_small, 8,8,8, 1}; + if (s == 1 && fx <= 6 && fy <= 6 ) spec = {(void*)upfirdn2d_kernel_small, 8,8,8, 1}; + if (s == 1 && fx <= 4 && fy <= 4 ) spec = {(void*)upfirdn2d_kernel_small, 8,8,8, 1}; + if (s == 1 && fx <= 2 && fy <= 2 ) spec = {(void*)upfirdn2d_kernel_small, 8,8,8, 1}; + } + if (p.up.x == 1 && p.up.y == 1 && p.down.x == 2 && p.down.y == 1) + { + // contiguous + if (s != 1 && fx <= 24 && fy <= 1) spec = {(void*)upfirdn2d_kernel_small, 64,8,1, 1}; + if (s != 1 && fx <= 16 && fy <= 1) spec = {(void*)upfirdn2d_kernel_small, 64,8,1, 1}; + if (s != 1 && fx <= 8 && fy <= 1) spec = {(void*)upfirdn2d_kernel_small, 64,8,1, 1}; + // channels_last + if (s == 1 && fx <= 24 && fy <= 1) spec = {(void*)upfirdn2d_kernel_small, 64,1,8, 1}; + if (s == 1 && fx <= 16 && fy <= 1) spec = {(void*)upfirdn2d_kernel_small, 64,1,8, 1}; + if (s == 1 && fx <= 8 && fy <= 1) spec = {(void*)upfirdn2d_kernel_small, 64,1,8, 1}; + } + if (p.up.x == 1 && p.up.y == 1 && p.down.x == 1 && p.down.y == 2) + { + // contiguous + if (s != 1 && fx <= 1 && fy <= 24) spec = {(void*)upfirdn2d_kernel_small, 32,16,1, 1}; + if (s != 1 && fx <= 1 && fy <= 16) spec = {(void*)upfirdn2d_kernel_small, 32,16,1, 1}; + if (s != 1 && fx <= 1 && fy <= 8 ) spec = {(void*)upfirdn2d_kernel_small, 32,16,1, 1}; + // channels_last + if (s == 1 && fx <= 1 && fy <= 24) spec = {(void*)upfirdn2d_kernel_small, 1,64,8, 1}; + if (s == 1 && fx <= 1 && fy <= 16) spec = {(void*)upfirdn2d_kernel_small, 1,64,8, 1}; + if (s == 1 && fx <= 1 && fy <= 8 ) spec = {(void*)upfirdn2d_kernel_small, 1,64,8, 1}; + } + + // 4x upsampling. + if (p.up.x == 4 && p.up.y == 4 && p.down.x == 1 && p.down.y == 1) + { + // contiguous + if (s != 1 && fx <= 48 && fy <= 48) spec = {(void*)upfirdn2d_kernel_small, 64,32,1, 1}; + if (s != 1 && fx <= 32 && fy <= 32) spec = {(void*)upfirdn2d_kernel_small, 64,32,1, 1}; + // channels_last + if (s == 1 && fx <= 48 && fy <= 48) spec = {(void*)upfirdn2d_kernel_small, 32,32,1, 1}; + if (s == 1 && fx <= 32 && fy <= 32) spec = {(void*)upfirdn2d_kernel_small, 32,32,1, 1}; + } + if (p.up.x == 4 && p.up.y == 1 && p.down.x == 1 && p.down.y == 1) + { + // contiguous + if (s != 1 && fx <= 48 && fy <= 1) spec = {(void*)upfirdn2d_kernel_small, 128,8,1, 1}; + if (s != 1 && fx <= 32 && fy <= 1) spec = {(void*)upfirdn2d_kernel_small, 128,8,1, 1}; + // channels_last + if (s == 1 && fx <= 48 && fy <= 1) spec = {(void*)upfirdn2d_kernel_small, 128,1,16, 1}; + if (s == 1 && fx <= 32 && fy <= 1) spec = {(void*)upfirdn2d_kernel_small, 128,1,16, 1}; + } + if (p.up.x == 1 && p.up.y == 4 && p.down.x == 1 && p.down.y == 1) + { + // contiguous + if (s != 1 && fx <= 1 && fy <= 48) spec = {(void*)upfirdn2d_kernel_small, 32,32,1, 1}; + if (s != 1 && fx <= 1 && fy <= 32) spec = {(void*)upfirdn2d_kernel_small, 32,32,1, 1}; + // channels_last + if (s == 1 && fx <= 1 && fy <= 48) spec = {(void*)upfirdn2d_kernel_small, 1,128,16, 1}; + if (s == 1 && fx <= 1 && fy <= 32) spec = {(void*)upfirdn2d_kernel_small, 1,128,16, 1}; + } + + // 4x downsampling (inefficient). + if (p.up.x == 1 && p.up.y == 1 && p.down.x == 4 && p.down.y == 1) + { + // contiguous + if (s != 1 && fx <= 48 && fy <= 1) spec = {(void*)upfirdn2d_kernel_small, 32,8,1, 1}; + if (s != 1 && fx <= 32 && fy <= 1) spec = {(void*)upfirdn2d_kernel_small, 32,8,1, 1}; + // channels_last + if (s == 1 && fx <= 48 && fy <= 1) spec = {(void*)upfirdn2d_kernel_small, 32,1,8, 1}; + if (s == 1 && fx <= 32 && fy <= 1) spec = {(void*)upfirdn2d_kernel_small, 32,1,8, 1}; + } + if (p.up.x == 1 && p.up.y == 1 && p.down.x == 1 && p.down.y == 4) + { + // contiguous + if (s != 1 && fx <= 1 && fy <= 48) spec = {(void*)upfirdn2d_kernel_small, 32,8,1, 1}; + if (s != 1 && fx <= 1 && fy <= 32) spec = {(void*)upfirdn2d_kernel_small, 32,8,1, 1}; + // channels_last + if (s == 1 && fx <= 1 && fy <= 48) spec = {(void*)upfirdn2d_kernel_small, 1,32,8, 1}; + if (s == 1 && fx <= 1 && fy <= 32) spec = {(void*)upfirdn2d_kernel_small, 1,32,8, 1}; + } + return spec; +} + +//------------------------------------------------------------------------ +// Template specializations. + +template upfirdn2d_kernel_spec choose_upfirdn2d_kernel (const upfirdn2d_kernel_params& p); +template upfirdn2d_kernel_spec choose_upfirdn2d_kernel (const upfirdn2d_kernel_params& p); +template upfirdn2d_kernel_spec choose_upfirdn2d_kernel(const upfirdn2d_kernel_params& p); + +//------------------------------------------------------------------------ diff --git a/torch_utils/ops/upfirdn2d.h b/torch_utils/ops/upfirdn2d.h new file mode 100644 index 0000000..2793daf --- /dev/null +++ b/torch_utils/ops/upfirdn2d.h @@ -0,0 +1,59 @@ +// Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + +#include + +//------------------------------------------------------------------------ +// CUDA kernel parameters. + +struct upfirdn2d_kernel_params +{ + const void* x; + const float* f; + void* y; + + int2 up; + int2 down; + int2 pad0; + int flip; + float gain; + + int4 inSize; // [width, height, channel, batch] + int4 inStride; + int2 filterSize; // [width, height] + int2 filterStride; + int4 outSize; // [width, height, channel, batch] + int4 outStride; + int sizeMinor; + int sizeMajor; + + int loopMinor; + int loopMajor; + int loopX; + int launchMinor; + int launchMajor; +}; + +//------------------------------------------------------------------------ +// CUDA kernel specialization. + +struct upfirdn2d_kernel_spec +{ + void* kernel; + int tileOutW; + int tileOutH; + int loopMinor; + int loopX; +}; + +//------------------------------------------------------------------------ +// CUDA kernel selection. + +template upfirdn2d_kernel_spec choose_upfirdn2d_kernel(const upfirdn2d_kernel_params& p); + +//------------------------------------------------------------------------ diff --git a/torch_utils/ops/upfirdn2d.py b/torch_utils/ops/upfirdn2d.py new file mode 100644 index 0000000..394f746 --- /dev/null +++ b/torch_utils/ops/upfirdn2d.py @@ -0,0 +1,389 @@ +# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +"""Custom PyTorch ops for efficient resampling of 2D images.""" + +import os +import numpy as np +import torch + +from .. import custom_ops +from .. import misc +from . import conv2d_gradfix + +#---------------------------------------------------------------------------- + +_plugin = None + +def _init(): + global _plugin + if _plugin is None: + _plugin = custom_ops.get_plugin( + module_name='upfirdn2d_plugin', + sources=['upfirdn2d.cpp', 'upfirdn2d.cu'], + headers=['upfirdn2d.h'], + source_dir=os.path.dirname(__file__), + extra_cuda_cflags=['--use_fast_math', '--allow-unsupported-compiler'], + ) + return True + +def _parse_scaling(scaling): + if isinstance(scaling, int): + scaling = [scaling, scaling] + assert isinstance(scaling, (list, tuple)) + assert all(isinstance(x, int) for x in scaling) + sx, sy = scaling + assert sx >= 1 and sy >= 1 + return sx, sy + +def _parse_padding(padding): + if isinstance(padding, int): + padding = [padding, padding] + assert isinstance(padding, (list, tuple)) + assert all(isinstance(x, int) for x in padding) + if len(padding) == 2: + padx, pady = padding + padding = [padx, padx, pady, pady] + padx0, padx1, pady0, pady1 = padding + return padx0, padx1, pady0, pady1 + +def _get_filter_size(f): + if f is None: + return 1, 1 + assert isinstance(f, torch.Tensor) and f.ndim in [1, 2] + fw = f.shape[-1] + fh = f.shape[0] + with misc.suppress_tracer_warnings(): + fw = int(fw) + fh = int(fh) + misc.assert_shape(f, [fh, fw][:f.ndim]) + assert fw >= 1 and fh >= 1 + return fw, fh + +#---------------------------------------------------------------------------- + +def setup_filter(f, device=torch.device('cpu'), normalize=True, flip_filter=False, gain=1, separable=None): + r"""Convenience function to setup 2D FIR filter for `upfirdn2d()`. + + Args: + f: Torch tensor, numpy array, or python list of the shape + `[filter_height, filter_width]` (non-separable), + `[filter_taps]` (separable), + `[]` (impulse), or + `None` (identity). + device: Result device (default: cpu). + normalize: Normalize the filter so that it retains the magnitude + for constant input signal (DC)? (default: True). + flip_filter: Flip the filter? (default: False). + gain: Overall scaling factor for signal magnitude (default: 1). + separable: Return a separable filter? (default: select automatically). + + Returns: + Float32 tensor of the shape + `[filter_height, filter_width]` (non-separable) or + `[filter_taps]` (separable). + """ + # Validate. + if f is None: + f = 1 + f = torch.as_tensor(f, dtype=torch.float32) + assert f.ndim in [0, 1, 2] + assert f.numel() > 0 + if f.ndim == 0: + f = f[np.newaxis] + + # Separable? + if separable is None: + separable = (f.ndim == 1 and f.numel() >= 8) + if f.ndim == 1 and not separable: + f = f.ger(f) + assert f.ndim == (1 if separable else 2) + + # Apply normalize, flip, gain, and device. + if normalize: + f /= f.sum() + if flip_filter: + f = f.flip(list(range(f.ndim))) + f = f * (gain ** (f.ndim / 2)) + f = f.to(device=device) + return f + +#---------------------------------------------------------------------------- + +def upfirdn2d(x, f, up=1, down=1, padding=0, flip_filter=False, gain=1, impl='cuda'): + r"""Pad, upsample, filter, and downsample a batch of 2D images. + + Performs the following sequence of operations for each channel: + + 1. Upsample the image by inserting N-1 zeros after each pixel (`up`). + + 2. Pad the image with the specified number of zeros on each side (`padding`). + Negative padding corresponds to cropping the image. + + 3. Convolve the image with the specified 2D FIR filter (`f`), shrinking it + so that the footprint of all output pixels lies within the input image. + + 4. Downsample the image by keeping every Nth pixel (`down`). + + This sequence of operations bears close resemblance to scipy.signal.upfirdn(). + The fused op is considerably more efficient than performing the same calculation + using standard PyTorch ops. It supports gradients of arbitrary order. + + Args: + x: Float32/float64/float16 input tensor of the shape + `[batch_size, num_channels, in_height, in_width]`. + f: Float32 FIR filter of the shape + `[filter_height, filter_width]` (non-separable), + `[filter_taps]` (separable), or + `None` (identity). + up: Integer upsampling factor. Can be a single int or a list/tuple + `[x, y]` (default: 1). + down: Integer downsampling factor. Can be a single int or a list/tuple + `[x, y]` (default: 1). + padding: Padding with respect to the upsampled image. Can be a single number + or a list/tuple `[x, y]` or `[x_before, x_after, y_before, y_after]` + (default: 0). + flip_filter: False = convolution, True = correlation (default: False). + gain: Overall scaling factor for signal magnitude (default: 1). + impl: Implementation to use. Can be `'ref'` or `'cuda'` (default: `'cuda'`). + + Returns: + Tensor of the shape `[batch_size, num_channels, out_height, out_width]`. + """ + assert isinstance(x, torch.Tensor) + assert impl in ['ref', 'cuda'] + if impl == 'cuda' and x.device.type == 'cuda' and _init(): + return _upfirdn2d_cuda(up=up, down=down, padding=padding, flip_filter=flip_filter, gain=gain).apply(x, f) + return _upfirdn2d_ref(x, f, up=up, down=down, padding=padding, flip_filter=flip_filter, gain=gain) + +#---------------------------------------------------------------------------- + +@misc.profiled_function +def _upfirdn2d_ref(x, f, up=1, down=1, padding=0, flip_filter=False, gain=1): + """Slow reference implementation of `upfirdn2d()` using standard PyTorch ops. + """ + # Validate arguments. + assert isinstance(x, torch.Tensor) and x.ndim == 4 + if f is None: + f = torch.ones([1, 1], dtype=torch.float32, device=x.device) + assert isinstance(f, torch.Tensor) and f.ndim in [1, 2] + assert f.dtype == torch.float32 and not f.requires_grad + batch_size, num_channels, in_height, in_width = x.shape + upx, upy = _parse_scaling(up) + downx, downy = _parse_scaling(down) + padx0, padx1, pady0, pady1 = _parse_padding(padding) + + # Check that upsampled buffer is not smaller than the filter. + upW = in_width * upx + padx0 + padx1 + upH = in_height * upy + pady0 + pady1 + assert upW >= f.shape[-1] and upH >= f.shape[0] + + # Upsample by inserting zeros. + x = x.reshape([batch_size, num_channels, in_height, 1, in_width, 1]) + x = torch.nn.functional.pad(x, [0, upx - 1, 0, 0, 0, upy - 1]) + x = x.reshape([batch_size, num_channels, in_height * upy, in_width * upx]) + + # Pad or crop. + x = torch.nn.functional.pad(x, [max(padx0, 0), max(padx1, 0), max(pady0, 0), max(pady1, 0)]) + x = x[:, :, max(-pady0, 0) : x.shape[2] - max(-pady1, 0), max(-padx0, 0) : x.shape[3] - max(-padx1, 0)] + + # Setup filter. + f = f * (gain ** (f.ndim / 2)) + f = f.to(x.dtype) + if not flip_filter: + f = f.flip(list(range(f.ndim))) + + # Convolve with the filter. + f = f[np.newaxis, np.newaxis].repeat([num_channels, 1] + [1] * f.ndim) + if f.ndim == 4: + x = conv2d_gradfix.conv2d(input=x, weight=f, groups=num_channels) + else: + x = conv2d_gradfix.conv2d(input=x, weight=f.unsqueeze(2), groups=num_channels) + x = conv2d_gradfix.conv2d(input=x, weight=f.unsqueeze(3), groups=num_channels) + + # Downsample by throwing away pixels. + x = x[:, :, ::downy, ::downx] + return x + +#---------------------------------------------------------------------------- + +_upfirdn2d_cuda_cache = dict() + +def _upfirdn2d_cuda(up=1, down=1, padding=0, flip_filter=False, gain=1): + """Fast CUDA implementation of `upfirdn2d()` using custom ops. + """ + # Parse arguments. + upx, upy = _parse_scaling(up) + downx, downy = _parse_scaling(down) + padx0, padx1, pady0, pady1 = _parse_padding(padding) + + # Lookup from cache. + key = (upx, upy, downx, downy, padx0, padx1, pady0, pady1, flip_filter, gain) + if key in _upfirdn2d_cuda_cache: + return _upfirdn2d_cuda_cache[key] + + # Forward op. + class Upfirdn2dCuda(torch.autograd.Function): + @staticmethod + def forward(ctx, x, f): # pylint: disable=arguments-differ + assert isinstance(x, torch.Tensor) and x.ndim == 4 + if f is None: + f = torch.ones([1, 1], dtype=torch.float32, device=x.device) + if f.ndim == 1 and f.shape[0] == 1: + f = f.square().unsqueeze(0) # Convert separable-1 into full-1x1. + assert isinstance(f, torch.Tensor) and f.ndim in [1, 2] + y = x + if f.ndim == 2: + y = _plugin.upfirdn2d(y, f, upx, upy, downx, downy, padx0, padx1, pady0, pady1, flip_filter, gain) + else: + y = _plugin.upfirdn2d(y, f.unsqueeze(0), upx, 1, downx, 1, padx0, padx1, 0, 0, flip_filter, 1.0) + y = _plugin.upfirdn2d(y, f.unsqueeze(1), 1, upy, 1, downy, 0, 0, pady0, pady1, flip_filter, gain) + ctx.save_for_backward(f) + ctx.x_shape = x.shape + return y + + @staticmethod + def backward(ctx, dy): # pylint: disable=arguments-differ + f, = ctx.saved_tensors + _, _, ih, iw = ctx.x_shape + _, _, oh, ow = dy.shape + fw, fh = _get_filter_size(f) + p = [ + fw - padx0 - 1, + iw * upx - ow * downx + padx0 - upx + 1, + fh - pady0 - 1, + ih * upy - oh * downy + pady0 - upy + 1, + ] + dx = None + df = None + + if ctx.needs_input_grad[0]: + dx = _upfirdn2d_cuda(up=down, down=up, padding=p, flip_filter=(not flip_filter), gain=gain).apply(dy, f) + + assert not ctx.needs_input_grad[1] + return dx, df + + # Add to cache. + _upfirdn2d_cuda_cache[key] = Upfirdn2dCuda + return Upfirdn2dCuda + +#---------------------------------------------------------------------------- + +def filter2d(x, f, padding=0, flip_filter=False, gain=1, impl='cuda'): + r"""Filter a batch of 2D images using the given 2D FIR filter. + + By default, the result is padded so that its shape matches the input. + User-specified padding is applied on top of that, with negative values + indicating cropping. Pixels outside the image are assumed to be zero. + + Args: + x: Float32/float64/float16 input tensor of the shape + `[batch_size, num_channels, in_height, in_width]`. + f: Float32 FIR filter of the shape + `[filter_height, filter_width]` (non-separable), + `[filter_taps]` (separable), or + `None` (identity). + padding: Padding with respect to the output. Can be a single number or a + list/tuple `[x, y]` or `[x_before, x_after, y_before, y_after]` + (default: 0). + flip_filter: False = convolution, True = correlation (default: False). + gain: Overall scaling factor for signal magnitude (default: 1). + impl: Implementation to use. Can be `'ref'` or `'cuda'` (default: `'cuda'`). + + Returns: + Tensor of the shape `[batch_size, num_channels, out_height, out_width]`. + """ + padx0, padx1, pady0, pady1 = _parse_padding(padding) + fw, fh = _get_filter_size(f) + p = [ + padx0 + fw // 2, + padx1 + (fw - 1) // 2, + pady0 + fh // 2, + pady1 + (fh - 1) // 2, + ] + return upfirdn2d(x, f, padding=p, flip_filter=flip_filter, gain=gain, impl=impl) + +#---------------------------------------------------------------------------- + +def upsample2d(x, f, up=2, padding=0, flip_filter=False, gain=1, impl='cuda'): + r"""Upsample a batch of 2D images using the given 2D FIR filter. + + By default, the result is padded so that its shape is a multiple of the input. + User-specified padding is applied on top of that, with negative values + indicating cropping. Pixels outside the image are assumed to be zero. + + Args: + x: Float32/float64/float16 input tensor of the shape + `[batch_size, num_channels, in_height, in_width]`. + f: Float32 FIR filter of the shape + `[filter_height, filter_width]` (non-separable), + `[filter_taps]` (separable), or + `None` (identity). + up: Integer upsampling factor. Can be a single int or a list/tuple + `[x, y]` (default: 1). + padding: Padding with respect to the output. Can be a single number or a + list/tuple `[x, y]` or `[x_before, x_after, y_before, y_after]` + (default: 0). + flip_filter: False = convolution, True = correlation (default: False). + gain: Overall scaling factor for signal magnitude (default: 1). + impl: Implementation to use. Can be `'ref'` or `'cuda'` (default: `'cuda'`). + + Returns: + Tensor of the shape `[batch_size, num_channels, out_height, out_width]`. + """ + upx, upy = _parse_scaling(up) + padx0, padx1, pady0, pady1 = _parse_padding(padding) + fw, fh = _get_filter_size(f) + p = [ + padx0 + (fw + upx - 1) // 2, + padx1 + (fw - upx) // 2, + pady0 + (fh + upy - 1) // 2, + pady1 + (fh - upy) // 2, + ] + return upfirdn2d(x, f, up=up, padding=p, flip_filter=flip_filter, gain=gain*upx*upy, impl=impl) + +#---------------------------------------------------------------------------- + +def downsample2d(x, f, down=2, padding=0, flip_filter=False, gain=1, impl='cuda'): + r"""Downsample a batch of 2D images using the given 2D FIR filter. + + By default, the result is padded so that its shape is a fraction of the input. + User-specified padding is applied on top of that, with negative values + indicating cropping. Pixels outside the image are assumed to be zero. + + Args: + x: Float32/float64/float16 input tensor of the shape + `[batch_size, num_channels, in_height, in_width]`. + f: Float32 FIR filter of the shape + `[filter_height, filter_width]` (non-separable), + `[filter_taps]` (separable), or + `None` (identity). + down: Integer downsampling factor. Can be a single int or a list/tuple + `[x, y]` (default: 1). + padding: Padding with respect to the input. Can be a single number or a + list/tuple `[x, y]` or `[x_before, x_after, y_before, y_after]` + (default: 0). + flip_filter: False = convolution, True = correlation (default: False). + gain: Overall scaling factor for signal magnitude (default: 1). + impl: Implementation to use. Can be `'ref'` or `'cuda'` (default: `'cuda'`). + + Returns: + Tensor of the shape `[batch_size, num_channels, out_height, out_width]`. + """ + downx, downy = _parse_scaling(down) + padx0, padx1, pady0, pady1 = _parse_padding(padding) + fw, fh = _get_filter_size(f) + p = [ + padx0 + (fw - downx + 1) // 2, + padx1 + (fw - downx) // 2, + pady0 + (fh - downy + 1) // 2, + pady1 + (fh - downy) // 2, + ] + return upfirdn2d(x, f, down=down, padding=p, flip_filter=flip_filter, gain=gain, impl=impl) + +#---------------------------------------------------------------------------- diff --git a/torch_utils/persistence.py b/torch_utils/persistence.py new file mode 100644 index 0000000..f90ce85 --- /dev/null +++ b/torch_utils/persistence.py @@ -0,0 +1,251 @@ +# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +"""Facilities for pickling Python code alongside other data. + +The pickled code is automatically imported into a separate Python module +during unpickling. This way, any previously exported pickles will remain +usable even if the original code is no longer available, or if the current +version of the code is not consistent with what was originally pickled.""" + +import sys +import pickle +import io +import inspect +import copy +import uuid +import types +import dnnlib + +#---------------------------------------------------------------------------- + +_version = 6 # internal version number +_decorators = set() # {decorator_class, ...} +_import_hooks = [] # [hook_function, ...] +_module_to_src_dict = dict() # {module: src, ...} +_src_to_module_dict = dict() # {src: module, ...} + +#---------------------------------------------------------------------------- + +def persistent_class(orig_class): + r"""Class decorator that extends a given class to save its source code + when pickled. + + Example: + + from torch_utils import persistence + + @persistence.persistent_class + class MyNetwork(torch.nn.Module): + def __init__(self, num_inputs, num_outputs): + super().__init__() + self.fc = MyLayer(num_inputs, num_outputs) + ... + + @persistence.persistent_class + class MyLayer(torch.nn.Module): + ... + + When pickled, any instance of `MyNetwork` and `MyLayer` will save its + source code alongside other internal state (e.g., parameters, buffers, + and submodules). This way, any previously exported pickle will remain + usable even if the class definitions have been modified or are no + longer available. + + The decorator saves the source code of the entire Python module + containing the decorated class. It does *not* save the source code of + any imported modules. Thus, the imported modules must be available + during unpickling, also including `torch_utils.persistence` itself. + + It is ok to call functions defined in the same module from the + decorated class. However, if the decorated class depends on other + classes defined in the same module, they must be decorated as well. + This is illustrated in the above example in the case of `MyLayer`. + + It is also possible to employ the decorator just-in-time before + calling the constructor. For example: + + cls = MyLayer + if want_to_make_it_persistent: + cls = persistence.persistent_class(cls) + layer = cls(num_inputs, num_outputs) + + As an additional feature, the decorator also keeps track of the + arguments that were used to construct each instance of the decorated + class. The arguments can be queried via `obj.init_args` and + `obj.init_kwargs`, and they are automatically pickled alongside other + object state. A typical use case is to first unpickle a previous + instance of a persistent class, and then upgrade it to use the latest + version of the source code: + + with open('old_pickle.pkl', 'rb') as f: + old_net = pickle.load(f) + new_net = MyNetwork(*old_obj.init_args, **old_obj.init_kwargs) + misc.copy_params_and_buffers(old_net, new_net, require_all=True) + """ + assert isinstance(orig_class, type) + if is_persistent(orig_class): + return orig_class + + assert orig_class.__module__ in sys.modules + orig_module = sys.modules[orig_class.__module__] + orig_module_src = _module_to_src(orig_module) + + class Decorator(orig_class): + _orig_module_src = orig_module_src + _orig_class_name = orig_class.__name__ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self._init_args = copy.deepcopy(args) + self._init_kwargs = copy.deepcopy(kwargs) + assert orig_class.__name__ in orig_module.__dict__ + _check_pickleable(self.__reduce__()) + + @property + def init_args(self): + return copy.deepcopy(self._init_args) + + @property + def init_kwargs(self): + return dnnlib.EasyDict(copy.deepcopy(self._init_kwargs)) + + def __reduce__(self): + fields = list(super().__reduce__()) + fields += [None] * max(3 - len(fields), 0) + if fields[0] is not _reconstruct_persistent_obj: + meta = dict(type='class', version=_version, module_src=self._orig_module_src, class_name=self._orig_class_name, state=fields[2]) + fields[0] = _reconstruct_persistent_obj # reconstruct func + fields[1] = (meta,) # reconstruct args + fields[2] = None # state dict + return tuple(fields) + + Decorator.__name__ = orig_class.__name__ + _decorators.add(Decorator) + return Decorator + +#---------------------------------------------------------------------------- + +def is_persistent(obj): + r"""Test whether the given object or class is persistent, i.e., + whether it will save its source code when pickled. + """ + try: + if obj in _decorators: + return True + except TypeError: + pass + return type(obj) in _decorators # pylint: disable=unidiomatic-typecheck + +#---------------------------------------------------------------------------- + +def import_hook(hook): + r"""Register an import hook that is called whenever a persistent object + is being unpickled. A typical use case is to patch the pickled source + code to avoid errors and inconsistencies when the API of some imported + module has changed. + + The hook should have the following signature: + + hook(meta) -> modified meta + + `meta` is an instance of `dnnlib.EasyDict` with the following fields: + + type: Type of the persistent object, e.g. `'class'`. + version: Internal version number of `torch_utils.persistence`. + module_src Original source code of the Python module. + class_name: Class name in the original Python module. + state: Internal state of the object. + + Example: + + @persistence.import_hook + def wreck_my_network(meta): + if meta.class_name == 'MyNetwork': + print('MyNetwork is being imported. I will wreck it!') + meta.module_src = meta.module_src.replace("True", "False") + return meta + """ + assert callable(hook) + _import_hooks.append(hook) + +#---------------------------------------------------------------------------- + +def _reconstruct_persistent_obj(meta): + r"""Hook that is called internally by the `pickle` module to unpickle + a persistent object. + """ + meta = dnnlib.EasyDict(meta) + meta.state = dnnlib.EasyDict(meta.state) + for hook in _import_hooks: + meta = hook(meta) + assert meta is not None + + assert meta.version == _version + module = _src_to_module(meta.module_src) + + assert meta.type == 'class' + orig_class = module.__dict__[meta.class_name] + decorator_class = persistent_class(orig_class) + obj = decorator_class.__new__(decorator_class) + + setstate = getattr(obj, '__setstate__', None) + if callable(setstate): + setstate(meta.state) # pylint: disable=not-callable + else: + obj.__dict__.update(meta.state) + return obj + +#---------------------------------------------------------------------------- + +def _module_to_src(module): + r"""Query the source code of a given Python module. + """ + src = _module_to_src_dict.get(module, None) + if src is None: + src = inspect.getsource(module) + _module_to_src_dict[module] = src + _src_to_module_dict[src] = module + return src + +def _src_to_module(src): + r"""Get or create a Python module for the given source code. + """ + module = _src_to_module_dict.get(src, None) + if module is None: + module_name = "_imported_module_" + uuid.uuid4().hex + module = types.ModuleType(module_name) + sys.modules[module_name] = module + _module_to_src_dict[module] = src + _src_to_module_dict[src] = module + exec(src, module.__dict__) # pylint: disable=exec-used + return module + +#---------------------------------------------------------------------------- + +def _check_pickleable(obj): + r"""Check that the given object is pickleable, raising an exception if + it is not. This function is expected to be considerably more efficient + than actually pickling the object. + """ + def recurse(obj): + if isinstance(obj, (list, tuple, set)): + return [recurse(x) for x in obj] + if isinstance(obj, dict): + return [[recurse(x), recurse(y)] for x, y in obj.items()] + if isinstance(obj, (str, int, float, bool, bytes, bytearray)): + return None # Python primitive types are pickleable. + if f'{type(obj).__module__}.{type(obj).__name__}' in ['numpy.ndarray', 'torch.Tensor', 'torch.nn.parameter.Parameter']: + return None # NumPy arrays and PyTorch tensors are pickleable. + if is_persistent(obj): + return None # Persistent objects are pickleable, by virtue of the constructor check. + return obj + with io.BytesIO() as f: + pickle.dump(recurse(obj), f) + +#---------------------------------------------------------------------------- diff --git a/torch_utils/training_stats.py b/torch_utils/training_stats.py new file mode 100644 index 0000000..5de4134 --- /dev/null +++ b/torch_utils/training_stats.py @@ -0,0 +1,268 @@ +# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION and its licensors retain all intellectual property +# and proprietary rights in and to this software, related documentation +# and any modifications thereto. Any use, reproduction, disclosure or +# distribution of this software and related documentation without an express +# license agreement from NVIDIA CORPORATION is strictly prohibited. + +"""Facilities for reporting and collecting training statistics across +multiple processes and devices. The interface is designed to minimize +synchronization overhead as well as the amount of boilerplate in user +code.""" + +import re +import numpy as np +import torch +import dnnlib + +from . import misc + +#---------------------------------------------------------------------------- + +_num_moments = 3 # [num_scalars, sum_of_scalars, sum_of_squares] +_reduce_dtype = torch.float32 # Data type to use for initial per-tensor reduction. +_counter_dtype = torch.float64 # Data type to use for the internal counters. +_rank = 0 # Rank of the current process. +_sync_device = None # Device to use for multiprocess communication. None = single-process. +_sync_called = False # Has _sync() been called yet? +_counters = dict() # Running counters on each device, updated by report(): name => device => torch.Tensor +_cumulative = dict() # Cumulative counters on the CPU, updated by _sync(): name => torch.Tensor + +#---------------------------------------------------------------------------- + +def init_multiprocessing(rank, sync_device): + r"""Initializes `torch_utils.training_stats` for collecting statistics + across multiple processes. + + This function must be called after + `torch.distributed.init_process_group()` and before `Collector.update()`. + The call is not necessary if multi-process collection is not needed. + + Args: + rank: Rank of the current process. + sync_device: PyTorch device to use for inter-process + communication, or None to disable multi-process + collection. Typically `torch.device('cuda', rank)`. + """ + global _rank, _sync_device + assert not _sync_called + _rank = rank + _sync_device = sync_device + +#---------------------------------------------------------------------------- + +@misc.profiled_function +def report(name, value): + r"""Broadcasts the given set of scalars to all interested instances of + `Collector`, across device and process boundaries. + + This function is expected to be extremely cheap and can be safely + called from anywhere in the training loop, loss function, or inside a + `torch.nn.Module`. + + Warning: The current implementation expects the set of unique names to + be consistent across processes. Please make sure that `report()` is + called at least once for each unique name by each process, and in the + same order. If a given process has no scalars to broadcast, it can do + `report(name, [])` (empty list). + + Args: + name: Arbitrary string specifying the name of the statistic. + Averages are accumulated separately for each unique name. + value: Arbitrary set of scalars. Can be a list, tuple, + NumPy array, PyTorch tensor, or Python scalar. + + Returns: + The same `value` that was passed in. + """ + if name not in _counters: + _counters[name] = dict() + + elems = torch.as_tensor(value) + if elems.numel() == 0: + return value + + elems = elems.detach().flatten().to(_reduce_dtype) + moments = torch.stack([ + torch.ones_like(elems).sum(), + elems.sum(), + elems.square().sum(), + ]) + assert moments.ndim == 1 and moments.shape[0] == _num_moments + moments = moments.to(_counter_dtype) + + device = moments.device + if device not in _counters[name]: + _counters[name][device] = torch.zeros_like(moments) + _counters[name][device].add_(moments) + return value + +#---------------------------------------------------------------------------- + +def report0(name, value): + r"""Broadcasts the given set of scalars by the first process (`rank = 0`), + but ignores any scalars provided by the other processes. + See `report()` for further details. + """ + report(name, value if _rank == 0 else []) + return value + +#---------------------------------------------------------------------------- + +class Collector: + r"""Collects the scalars broadcasted by `report()` and `report0()` and + computes their long-term averages (mean and standard deviation) over + user-defined periods of time. + + The averages are first collected into internal counters that are not + directly visible to the user. They are then copied to the user-visible + state as a result of calling `update()` and can then be queried using + `mean()`, `std()`, `as_dict()`, etc. Calling `update()` also resets the + internal counters for the next round, so that the user-visible state + effectively reflects averages collected between the last two calls to + `update()`. + + Args: + regex: Regular expression defining which statistics to + collect. The default is to collect everything. + keep_previous: Whether to retain the previous averages if no + scalars were collected on a given round + (default: True). + """ + def __init__(self, regex='.*', keep_previous=True): + self._regex = re.compile(regex) + self._keep_previous = keep_previous + self._cumulative = dict() + self._moments = dict() + self.update() + self._moments.clear() + + def names(self): + r"""Returns the names of all statistics broadcasted so far that + match the regular expression specified at construction time. + """ + return [name for name in _counters if self._regex.fullmatch(name)] + + def update(self): + r"""Copies current values of the internal counters to the + user-visible state and resets them for the next round. + + If `keep_previous=True` was specified at construction time, the + operation is skipped for statistics that have received no scalars + since the last update, retaining their previous averages. + + This method performs a number of GPU-to-CPU transfers and one + `torch.distributed.all_reduce()`. It is intended to be called + periodically in the main training loop, typically once every + N training steps. + """ + if not self._keep_previous: + self._moments.clear() + for name, cumulative in _sync(self.names()): + if name not in self._cumulative: + self._cumulative[name] = torch.zeros([_num_moments], dtype=_counter_dtype) + delta = cumulative - self._cumulative[name] + self._cumulative[name].copy_(cumulative) + if float(delta[0]) != 0: + self._moments[name] = delta + + def _get_delta(self, name): + r"""Returns the raw moments that were accumulated for the given + statistic between the last two calls to `update()`, or zero if + no scalars were collected. + """ + assert self._regex.fullmatch(name) + if name not in self._moments: + self._moments[name] = torch.zeros([_num_moments], dtype=_counter_dtype) + return self._moments[name] + + def num(self, name): + r"""Returns the number of scalars that were accumulated for the given + statistic between the last two calls to `update()`, or zero if + no scalars were collected. + """ + delta = self._get_delta(name) + return int(delta[0]) + + def mean(self, name): + r"""Returns the mean of the scalars that were accumulated for the + given statistic between the last two calls to `update()`, or NaN if + no scalars were collected. + """ + delta = self._get_delta(name) + if int(delta[0]) == 0: + return float('nan') + return float(delta[1] / delta[0]) + + def std(self, name): + r"""Returns the standard deviation of the scalars that were + accumulated for the given statistic between the last two calls to + `update()`, or NaN if no scalars were collected. + """ + delta = self._get_delta(name) + if int(delta[0]) == 0 or not np.isfinite(float(delta[1])): + return float('nan') + if int(delta[0]) == 1: + return float(0) + mean = float(delta[1] / delta[0]) + raw_var = float(delta[2] / delta[0]) + return np.sqrt(max(raw_var - np.square(mean), 0)) + + def as_dict(self): + r"""Returns the averages accumulated between the last two calls to + `update()` as an `dnnlib.EasyDict`. The contents are as follows: + + dnnlib.EasyDict( + NAME = dnnlib.EasyDict(num=FLOAT, mean=FLOAT, std=FLOAT), + ... + ) + """ + stats = dnnlib.EasyDict() + for name in self.names(): + stats[name] = dnnlib.EasyDict(num=self.num(name), mean=self.mean(name), std=self.std(name)) + return stats + + def __getitem__(self, name): + r"""Convenience getter. + `collector[name]` is a synonym for `collector.mean(name)`. + """ + return self.mean(name) + +#---------------------------------------------------------------------------- + +def _sync(names): + r"""Synchronize the global cumulative counters across devices and + processes. Called internally by `Collector.update()`. + """ + if len(names) == 0: + return [] + global _sync_called + _sync_called = True + + # Collect deltas within current rank. + deltas = [] + device = _sync_device if _sync_device is not None else torch.device('cpu') + for name in names: + delta = torch.zeros([_num_moments], dtype=_counter_dtype, device=device) + for counter in _counters[name].values(): + delta.add_(counter.to(device)) + counter.copy_(torch.zeros_like(counter)) + deltas.append(delta) + deltas = torch.stack(deltas) + + # Sum deltas across ranks. + if _sync_device is not None: + torch.distributed.all_reduce(deltas) + + # Update cumulative values. + deltas = deltas.cpu() + for idx, name in enumerate(names): + if name not in _cumulative: + _cumulative[name] = torch.zeros([_num_moments], dtype=_counter_dtype) + _cumulative[name].add_(deltas[idx]) + + # Return name-value pairs. + return [(name, _cumulative[name]) for name in names] + +#---------------------------------------------------------------------------- diff --git a/workflow.png b/workflow.png new file mode 100644 index 0000000000000000000000000000000000000000..0d80f911dd6918886ee9156fe38ca096a79e9efd GIT binary patch literal 479682 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