srforge 0.1.0__tar.gz

srforge-0.1.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: srforge
+Version: 0.1.0
+Summary: Super‑resolution research framework for PyTorch with a focus on simplicity and flexibility using config files.
+Author-email: Tomasz Tarasiewicz <tarasiewicztomasz@gmail.com>
+Project-URL: Homepage, https://gitlab.com/tarasiewicztomasz/sr-forge
+Project-URL: Source, https://gitlab.com/tarasiewicztomasz/sr-forge/-/tree/main
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: torch>=2.7
+Requires-Dist: torchvision>=0.22
+Requires-Dist: torchaudio>=2.7
+Requires-Dist: torch-geometric>=2.6
+Requires-Dist: pyg-lib>=0.4
+Requires-Dist: torch-scatter>=2.1
+Requires-Dist: torch-sparse>=0.6
+Requires-Dist: torch-cluster>=1.6
+Requires-Dist: torch-spline-conv>=1.2
+Requires-Dist: torchdatasets>=0.2
+Requires-Dist: torchmetrics>=1.7
+Requires-Dist: hydra-core>=1.3
+Requires-Dist: einops>=0.8
+Requires-Dist: wandb>=0.21
+Requires-Dist: matplotlib>=3.10
+Requires-Dist: scikit-image>=0.25
+Requires-Dist: opencv-python>=4.12
+Requires-Dist: pandas>=2.3
+Requires-Dist: colorlog>=6.9
+Provides-Extra: cuda128
+Requires-Dist: torch==2.7.1+cu128; extra == "cuda128"
+Requires-Dist: torchvision==0.22.1+cu128; extra == "cuda128"
+Requires-Dist: torchaudio==2.7.1+cu128; extra == "cuda128"
+Requires-Dist: torch-geometric==2.6.1; extra == "cuda128"
+Requires-Dist: pyg-lib==0.4.0+pt27cu128; extra == "cuda128"
+Requires-Dist: torch-scatter==2.1.2+pt27cu128; extra == "cuda128"
+Requires-Dist: torch-sparse==0.6.18+pt27cu128; extra == "cuda128"
+Requires-Dist: torch-cluster==1.6.3+pt27cu128; extra == "cuda128"
+Requires-Dist: torch-spline-conv==1.2.2+pt27cu128; extra == "cuda128"
+
+# SR FORGE
+**Super-Resolution Framework for Oriented Restoration and Guided Enhancement**
+
+---
+
+SR FORGE (**S**uper-**R**esolution **F**ramework for **O**riented **R**estoration & **G**uided **E**nhancement) is a unified, modular, and task-driven framework for training and evaluating deep learning models in the field of super-resolution.
+
+## Key Features
+
+- **Structured Workflow**  
+  SR FORGE provides an **organized** approach to super resolution. Every step—from data loading to final evaluation—follows a clear, modular structure.
+
+- **Task-driven restoration**  
+  Built-in utilities to help fine-tune models for specific tasks or objectives (e.g., OCR, remote sensing, medical imaging, etc.).
+
+- **Config-Driven Experiments**  
+  Simple YAML/JSON configuration files let you customize your pipeline without modifying code directly.
+
+- **Flexible Model Plug-In**  
+  Easily integrate popular SISR (EDSR, RCAN, ESRGAN, etc.) and MISR (RAMS, HighRes-net, PIUNET, TR-MISR, MagNAt) or your own custom architecture.
+
+- **Unified Metrics**  
+  Evaluate your models with a suite of standard metrics (PSNR, SSIM, LPIPS) and straightforward logging.
+
+- **Visualization Tools**  
+  Quickly visualize results (side-by-side comparisons, zoom-ins, or overlays) for interpretability and debugging.
+
+## Installation
+
+1. **Clone the Repository**
+   ```bash
+   git clone https://github.com/your-username/sr-forge.git

srforge-0.1.0/README.md

@@ -0,0 +1,32 @@
+# SR FORGE
+**Super-Resolution Framework for Oriented Restoration and Guided Enhancement**
+
+---
+
+SR FORGE (**S**uper-**R**esolution **F**ramework for **O**riented **R**estoration & **G**uided **E**nhancement) is a unified, modular, and task-driven framework for training and evaluating deep learning models in the field of super-resolution.
+
+## Key Features
+
+- **Structured Workflow**  
+  SR FORGE provides an **organized** approach to super resolution. Every step—from data loading to final evaluation—follows a clear, modular structure.
+
+- **Task-driven restoration**  
+  Built-in utilities to help fine-tune models for specific tasks or objectives (e.g., OCR, remote sensing, medical imaging, etc.).
+
+- **Config-Driven Experiments**  
+  Simple YAML/JSON configuration files let you customize your pipeline without modifying code directly.
+
+- **Flexible Model Plug-In**  
+  Easily integrate popular SISR (EDSR, RCAN, ESRGAN, etc.) and MISR (RAMS, HighRes-net, PIUNET, TR-MISR, MagNAt) or your own custom architecture.
+
+- **Unified Metrics**  
+  Evaluate your models with a suite of standard metrics (PSNR, SSIM, LPIPS) and straightforward logging.
+
+- **Visualization Tools**  
+  Quickly visualize results (side-by-side comparisons, zoom-ins, or overlays) for interpretability and debugging.
+
+## Installation
+
+1. **Clone the Repository**
+   ```bash
+   git clone https://github.com/your-username/sr-forge.git

srforge-0.1.0/pyproject.toml

@@ -0,0 +1,77 @@
+[build-system]
+requires      = ["setuptools>=69", "wheel"]   # ↑ keep these up‑to‑date
+build-backend = "setuptools.build_meta"
+
+
+
+[project.urls]
+Homepage = "https://gitlab.com/tarasiewicztomasz/sr-forge"
+Source  = "https://gitlab.com/tarasiewicztomasz/sr-forge/-/tree/main"
+
+
+[project]                      # PEP 621 metadata
+name            = "srforge"    # pip install srforge
+version         = "0.1.0"
+description     = "Super‑resolution research framework for PyTorch with a focus on simplicity and flexibility using config files."
+readme          = "README.md"
+requires-python = ">=3.10"
+
+authors = [
+    { name = "Tomasz Tarasiewicz", email = "tarasiewicztomasz@gmail.com" }
+]
+
+dependencies = [
+    "torch>=2.7",                 # gets the CPU wheel by default
+    "torchvision>=0.22",
+    "torchaudio>=2.7",
+
+    "torch-geometric>=2.6",
+    "pyg-lib>=0.4",
+    "torch-scatter>=2.1",
+    "torch-sparse>=0.6",
+    "torch-cluster>=1.6",
+    "torch-spline-conv>=1.2",
+
+    "torchdatasets>=0.2",
+    "torchmetrics>=1.7",
+
+    "hydra-core>=1.3",
+    "einops>=0.8",
+    "wandb>=0.21",
+
+    "matplotlib>=3.10",
+    "scikit-image>=0.25",
+    "opencv-python>=4.12",
+    "pandas>=2.3",
+
+    "colorlog>=6.9"
+]
+
+# ────────────────────────────── CUDA 12.8 wheels ───────────────────────────────
+[project.optional-dependencies]
+cuda128 = [
+    "torch==2.7.1+cu128",
+    "torchvision==0.22.1+cu128",
+    "torchaudio==2.7.1+cu128",
+
+    "torch-geometric==2.6.1",
+    "pyg-lib==0.4.0+pt27cu128",
+    "torch-scatter==2.1.2+pt27cu128",
+    "torch-sparse==0.6.18+pt27cu128",
+    "torch-cluster==1.6.3+pt27cu128",
+    "torch-spline-conv==1.2.2+pt27cu128"
+]
+
+# 1) tell setuptools “only package the 'srforge' directory”
+[tool.setuptools]
+packages = ["srforge", "scripts"]         # easiest & explicit
+
+# alternatively you could use the automatic finder:
+# [tool.setuptools.packages.find]
+# include = ["srforge*"]       # but explicit is clearer
+
+
+# 2) expose console‑script entry‑points *optional*
+[project.scripts]
+train  = "scripts.train:main"
+test  = "scripts.test:main"

srforge-0.1.0/scripts/test.py

@@ -0,0 +1,104 @@
+import os
+import shutil
+from pathlib import Path
+
+from training.observers import ImageProcessor
+
+os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE" # IMPORT CORE AFTER THIS LINE !!!
+import logging
+from utils.logging import configure_logger
+configure_logger(logging.INFO)
+import hydra
+from hydra.core.hydra_config import HydraConfig
+from tqdm import tqdm
+
+import wandb
+import omegaconf
+from core import GlobalSettings
+import core.config.utils
+from core.config.legacy import ConfigParser
+from core.data.loader import DataLoaderFactory
+from core.training import runners, observers
+
+import torch
+import torchdatasets as td
+
+logger = logging.getLogger(__name__)
+
+@hydra.main(config_path="configs", config_name="test-cfg", version_base=None)
+def main(cfg) -> None:
+    core.config.utils.clear_defaults(cfg)
+    # Set global settings
+    GlobalSettings().config = cfg
+    GlobalSettings().output_directory = HydraConfig.get().runtime.output_dir
+
+    configure_logger(cfg.system.debug_level)# second time because hydra overrides current global logger configuration
+    out_dir = HydraConfig.get().runtime.output_dir
+    wandb.init(project=cfg.wandb.project, entity=cfg.wandb.entity, name=cfg.wandb.run_name,
+               id=cfg.wandb.run_id, group=cfg.wandb.group_name, notes=cfg.wandb.notes,
+               dir=out_dir, tags=cfg.wandb.tags, job_type='test', resume='never',
+               config=omegaconf.OmegaConf.to_container(cfg, resolve=False, throw_on_missing=True),
+               mode=cfg.wandb.mode, settings=wandb.Settings(x_disable_stats=True))
+
+    print('Configuring benchmark...')
+    print(f'Run ID: {wandb.run.id}')
+    print(f'Run Name: {wandb.run.name}')
+    print(f'Run path: {wandb.run.path}')
+
+    if isinstance(cfg.system.device, (list, tuple, omegaconf.ListConfig)):
+        raise NotImplementedError("Multi-GPU inference is not supported yet.")
+    else:
+        device = torch.device(cfg.system.device)
+        print(f"Using device: {device}")
+
+
+    parser = ConfigParser(cfg, wandb.run)
+    model = parser(cfg.model)
+    model.to(device)
+    metrics = parser(cfg.test_metrics)
+    test_dataset = parser(cfg.dataset)
+    postprocessor = parser(cfg.postprocessing)
+
+    if cfg.system.cache_dir is not None:
+        cache_path = Path(cfg.system.cache_dir) / 'cache' / f"{device.type}_{device.index}"
+        print(cache_path, cache_path.absolute())
+        os.makedirs(cache_path, exist_ok=True)
+        if os.path.isdir(cache_path) and cfg.system.recache:
+            shutil.rmtree(cache_path)
+        test_dataset = test_dataset.cache(td.cachers.Pickle(cache_path / 'test'))
+
+    test_loader = DataLoaderFactory(test_dataset, batch_size=1, shuffle=False,
+                                     num_workers=0, device=cfg.system.device).get_loader()
+
+    out_dir = Path(cfg.system.output_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    benchmark_runner = runners.BenchmarkRunner(metrics, device, postprocessor=postprocessor)
+    benchmark_runner.add_observer(observers.ProgressLogger("Testing"))
+    benchmark_runner.add_observer(observers.BatchImageSaver(
+        image_processor=ImageProcessor(65535.0, border=0, ),
+        output_path=out_dir,
+        dtype='uint16',
+    ))
+    benchmark_runner.add_observer(observers.BatchImageLogger(list(range(0, 50)),
+                                                             observers.ImageProcessor(
+                                                                 65535.0,
+                                                                 border=3,
+                                                                 equalize_mode='clahe'),
+                                                             # ref_key='hr',
+                                                             # img_key='sr',
+                                                             ))
+    benchmark_runner.add_observer(observers.TableLogger(
+        'test_benchmark',
+        'sr',
+        processor=observers.ImageProcessor(65535.0, 'clahe')
+    ))
+
+    benchmark_runner.run_epoch(model=model, data_loader=test_loader, epoch=0)
+    wandb.finish(0)
+
+
+
+
+if __name__ == "__main__":
+    main()

srforge-0.1.0/scripts/train.py

@@ -0,0 +1,140 @@
+import os
+import shutil
+from pathlib import Path
+
+os.environ["C10D_TCP_STORE_USE_LIBUV"] = "0"
+os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE" # IMPORT CORE AFTER THIS LINE !!!
+import logging
+from srforge.utils.logging import configure_logger
+configure_logger(logging.INFO)
+import hydra
+from hydra.core.hydra_config import HydraConfig
+
+import wandb
+import omegaconf
+from srforge import GlobalSettings
+import srforge.config.utils
+from srforge.config.legacy import ConfigParser
+from srforge.config import TrainConfig
+from srforge.dataset import Dataset
+from srforge.data.loader import DataLoaderFactory
+from srforge.data import Entry, GraphEntry
+
+from srforge.loss import Loss
+from srforge.training import runners, trainers, observers
+
+
+import torch
+import torch_geometric as tg
+import torchdatasets as td
+
+logger = logging.getLogger(__name__)
+
+@hydra.main(config_path="configs", config_name="train-cfg", version_base=None)
+def main(cfg) -> None:
+    cfg: TrainConfig
+    srforge.config.utils.clear_defaults(cfg)
+
+    # Set global settings
+    GlobalSettings().config = cfg
+    GlobalSettings().output_directory = HydraConfig.get().runtime.output_dir
+
+    configure_logger(cfg.system.debug_level)# second time because hydra overrides current global logger configuration
+    out_dir = HydraConfig.get().runtime.output_dir
+    wandb.init(project=cfg.wandb.project, entity=cfg.wandb.entity, name=cfg.wandb.run_name,
+               id=cfg.wandb.run_id, group=cfg.wandb.group_name, notes=cfg.wandb.notes,
+               dir=out_dir, tags=cfg.wandb.tags, job_type='training', resume='allow',
+               config=omegaconf.OmegaConf.to_container(cfg, resolve=False, throw_on_missing=True),
+               mode=cfg.wandb.mode)
+    print('Configuring training...')
+    print(f'Run ID: {wandb.run.id}')
+    print(f'Run Name: {wandb.run.name}')
+    print(f'Run path: {wandb.run.path}')
+    if wandb.run.resumed:
+        print(f'Training resumed: {wandb.run.resumed}\n')
+
+    multigpu_training = False
+    if isinstance(cfg.system.device, (list, tuple, omegaconf.ListConfig)):
+        device = torch.device(cfg.system.device[0])
+        if len(cfg.system.device) > 1:
+            multigpu_training = True
+        print(f"Using devices: {[torch.device(x) for x in cfg.system.device]}")
+    else:
+        device = torch.device(cfg.system.device)
+        print(f"Using device: {device}")
+
+
+    parser = ConfigParser(cfg, wandb.run)
+    initial_epoch, best_losses = parser.get_training_data()
+    model = parser.get_model()
+    model.to(device)
+    optimizer = parser.get_optimizer()
+    lr_scheduler = parser.get_lr_scheduler()
+    loss: Loss = parser(cfg.loss)
+    metrics = parser(cfg.validation_metrics)
+    train_dataset: Dataset = parser(cfg.dataset.training)
+    valid_dataset = parser(cfg.dataset.validation)
+    train_postprocessor = parser(cfg.postprocessing.training)
+    valid_postprocessor = parser(cfg.postprocessing.validation)
+
+    # train_dataset = train_dataset.take(12)
+    # valid_dataset = valid_dataset.take(12)
+
+    if cfg.system.cache_dir is not None:
+        cache_path = Path(cfg.system.cache_dir) / 'cache' / f"{device.type}_{device.index}"
+        print(cache_path, cache_path.absolute())
+        os.makedirs(cache_path, exist_ok=True)
+        if os.path.isdir(cache_path) and cfg.system.recache:
+            shutil.rmtree(cache_path)
+        train_dataset = train_dataset.cache(td.cachers.Pickle(cache_path / 'train'))
+        valid_dataset = valid_dataset.cache(td.cachers.Pickle(cache_path / 'val'))
+
+    train_loader = DataLoaderFactory(train_dataset, batch_size=cfg.training.batch_size, shuffle=True,
+                                     num_workers=cfg.training.num_workers, device=cfg.system.device,
+                                     pin_memory_device=str(device), pin_memory=True).get_loader()
+    val_loader = DataLoaderFactory(valid_dataset, batch_size=1, shuffle=False,
+                                   num_workers=0, device=cfg.system.device,
+                                   pin_memory_device=str(device), pin_memory=True).get_loader()
+
+
+
+    if multigpu_training:
+        first_element = train_dataset[0]
+        if isinstance(first_element, Entry):
+            model = torch.nn.DataParallel(model, device_ids=[torch.device(x).index for x in cfg.system.device])
+        elif isinstance(first_element, GraphEntry):
+            model = tg.nn.DataParallel(model, device_ids=[torch.device(x).index for x in cfg.system.device])
+
+    else:
+        device = torch.device(f'cuda:{cfg.system.device}')
+
+
+    wandb.watch(model if not isinstance(model, (tg.nn.DataParallel, torch.nn.DataParallel)) else model.module,
+                log='all', log_graph=True, log_freq=len(train_loader), criterion=loss)
+    print('Training started...')
+    train_runner = runners.TrainingEpochRunner(optimizer, loss,
+                                               postprocessor=train_postprocessor,
+                                               mixed_precision=cfg.system.mixed_precision,
+                                               device=device,
+                                               gradient_accumulation_steps=cfg.training.gradient_accumulation_steps)
+    train_runner.add_observer(observers.ProgressLogger("T"))
+    val_runner = runners.ValidationEpochRunner(loss_fn=metrics,
+                                               postprocessor=valid_postprocessor,
+                                               mixed_precision=cfg.system.mixed_precision,
+                                               device=device)
+    val_runner.add_observer(observers.ProgressLogger("V"))
+    val_runner.add_observer(observers.LogitsLogger(batch_id=0, ref_key='target_shifts', img_key='dynamic_filters',
+                                                   log_dir='dynamic_filters'))
+    trainer = trainers.PyTorchTrainer(model, train_runner, val_runner, scheduler=lr_scheduler,
+                                      initial_epoch=initial_epoch,)
+    # trainer.add_observer(observers.LossScheduler(loss_fn))
+    trainer.add_observer(observers.LossLogger())
+    trainer.add_observer(observers.PyTorchModelSaver(best_loss=best_losses['total'] if best_losses is not None else None))
+    trainer.train(cfg.training.epochs, train_loader, val_loader)
+    wandb.finish(0)
+
+
+
+
+if __name__ == "__main__":
+    main()

srforge-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

srforge-0.1.0/srforge/__init__.py

@@ -0,0 +1,23 @@
+from srforge.registry import ClassRegistry
+import logging
+logger = logging.getLogger(__name__)
+
+
+class Singleton(type):
+    _instances = {}
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super().__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+class GlobalSettings(metaclass=Singleton):
+    def __init__(self):
+        self.debug_mode = False
+        self.output_directory = 'output'
+        self.config = None
+
+    def __setattr__(self, key, value):
+        # logger.info(f"GlobalSettings: setting {key} to {value}")
+        super().__setattr__(key, value)
+
+ClassRegistry().discover(__name__)

srforge-0.1.0/srforge/registry.py

@@ -0,0 +1,150 @@
+import logging
+logger = logging.getLogger(__name__)
+import threading
+from typing import Type, Union
+import pkgutil
+import importlib
+from pathlib import Path
+import json
+import inspect
+import ast
+
+
+
+class ClassRegistry:
+    _instance = None
+    _lock = threading.Lock()
+    CLASS_REGISTRY_FILENAME = "class_registry.json"
+
+    # ────────────────────────────────────────────────────────── singleton ──
+    def __new__(cls, *args, **kwargs):
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super().__new__(cls)
+                cls._instance.classes = {}               # {name: (module, qualname)}
+                cls._instance._discovered = set()        # module names already walked
+        return cls._instance
+
+    # ──────────────────────────────────────────────── public API ──────────
+    def discover(self, root: Union[str, Path]):
+        """
+        Walk every .py file inside *root* and auto‑register any class decorated
+        with @register_class.  *root* may be:
+
+        * a dotted import name  –  "srforge" or "srforge.transform"
+        * a Path object         –  Path("src/srforge")
+        """
+        root_path, root_pkg = self._to_path_and_package(root)
+        if root_pkg in self._discovered:
+            return                      # already done
+
+        self._walk_source_tree(root_path, root_pkg)
+        self._discovered.add(root_pkg)
+        self._save_metadata(Path(__file__).parent.parent / "metadata")
+
+    def register(self, name: str, cls: Type):
+        """Register a class by the *public* name it should be looked up with."""
+        if any((m == cls.__module__ and n == cls.__name__)
+               for m, n in self.classes.values()):
+            return                      # identical class already known
+        self.classes[name] = (cls.__module__, cls.__name__)
+
+    # ──────────────────────────────────────────── internals ───────────────
+    @staticmethod
+    def _to_path_and_package(root: Union[str, Path]):
+        """Return (Path_to_folder, canonical_package_name)."""
+        if isinstance(root, Path):
+            # Convert src/srforge/... → srforge...
+            # The package name is the last folder that *contains* __init__.py
+            for parent in reversed(root.resolve().parents):
+                if (parent / "__init__.py").exists():
+                    pkg = ".".join(root.resolve().relative_to(parent).parts)
+                    full_pkg = f"{parent.name}.{pkg}" if pkg else parent.name
+                    return root.resolve(), full_pkg
+            raise RuntimeError(f"Cannot derive package name from {root}")
+
+        # dotted import name: find its spec
+        spec = importlib.util.find_spec(root)
+        if spec is None or spec.origin is None:
+            raise ImportError(f"Cannot import '{root}'")
+        if spec.submodule_search_locations:          # it’s a package
+            folder = Path(next(iter(spec.submodule_search_locations))).resolve()
+        else:                                        # it’s a single module file
+            folder = Path(spec.origin).resolve().parent
+        return folder, spec.name                     # spec.name is the canonical pkg
+
+    # --------------------------------------------------------------------
+    def _walk_source_tree(self, folder: Path, package_root: str):
+        """
+        Parse every .py file underneath *folder* and register classes that have
+        a @register_class decorator.
+        """
+        for py_file in folder.rglob("*.py"):
+            try:
+                tree = ast.parse(py_file.read_text("utf‑8"), filename=str(py_file))
+            except SyntaxError:
+                continue
+
+            rel_mod = ".".join(py_file.relative_to(folder).with_suffix("").parts)
+            module_name = f"{package_root}.{rel_mod}" if rel_mod else package_root
+
+            for node in tree.body:
+                if not isinstance(node, ast.ClassDef):
+                    continue
+                for deco in node.decorator_list:
+                    # @register_class           → ast.Name
+                    # @register_class("foo")    → ast.Call(func=ast.Name)
+                    if (isinstance(deco, ast.Name) and deco.id == "register_class") \
+                       or (isinstance(deco, ast.Call) and
+                           isinstance(deco.func, ast.Name) and deco.func.id == "register_class"):
+                        public = (node.name if isinstance(deco, ast.Name)
+                                  else (deco.args[0].value if deco.args else node.name))
+                        self.classes.setdefault(public, (module_name, node.name))
+                        break                                            # stop scanning decorators
+
+    # --------------------------------------------------------------------
+    def _save_metadata(self, path: Path):
+        path.mkdir(parents=True, exist_ok=True)
+        result = dict()
+
+        classes = list(self.classes.keys())
+        classes = sorted(classes, key=lambda x: x.lower())
+        result['by_class'] = {k: self.classes[k][0] for k in classes}
+
+        modules = sorted([self.classes[k][0] for k in self.classes])
+        x = {module: [] for module in modules}
+        for k, v in self.classes.items():
+            x[v[0]].append(k)
+        keys = sorted(x.keys())
+        result['by_module'] = {k: x[k] for k in keys},
+
+        with open(path / self.CLASS_REGISTRY_FILENAME, 'w') as f:
+            json.dump(result, f, indent=4)
+
+    def __contains__(self, name):
+        return self.has(name)
+
+    def get(self, name):
+        return self.classes.get(name)
+
+    def has(self, name):
+        return name in self.classes
+
+    def __repr__(self):
+        # pretty print
+        return f'ClassRegistry({self.classes})'
+
+def register_class(cls_or_name: Union[type, str] = None):
+    """
+    Decorator to register a class with its module path so that when loading from the yaml config file through _target
+    keyword, the class can be instantiated without the need of specifying the full module path.
+    """
+    def wrapper(cls):
+        # Get the full module path
+        class_name = cls.__name__ if isinstance(cls_or_name, type) or cls_or_name is None else cls_or_name
+        ClassRegistry().register(class_name, cls)
+        return cls
+
+    if isinstance(cls_or_name, type):
+        return wrapper(cls_or_name)
+    return wrapper

srforge-0.1.0/srforge/structs.py

@@ -0,0 +1,16 @@
+import collections
+
+AfterEpochDataToSave = collections.namedtuple("DataToSave",
+                                              ["optimizer",
+                                               "lr_scheduler",
+                                               "model",
+                                               "train_loss",
+                                               "val_loss",
+                                               "epoch",
+                                               "scaler"])
+
+LogPoint = collections.namedtuple("LogPoint", ["name", "value", "epoch"])
+
+EpochValidationResults = collections.namedtuple("EpochValidationResults",
+                                                ["epoch", "batch", "output", "input",
+                                                 "batch_metrics", "criterion", "epoch_metrics"])

srforge-0.1.0/srforge.egg-info/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: srforge
+Version: 0.1.0
+Summary: Super‑resolution research framework for PyTorch with a focus on simplicity and flexibility using config files.
+Author-email: Tomasz Tarasiewicz <tarasiewicztomasz@gmail.com>
+Project-URL: Homepage, https://gitlab.com/tarasiewicztomasz/sr-forge
+Project-URL: Source, https://gitlab.com/tarasiewicztomasz/sr-forge/-/tree/main
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: torch>=2.7
+Requires-Dist: torchvision>=0.22
+Requires-Dist: torchaudio>=2.7
+Requires-Dist: torch-geometric>=2.6
+Requires-Dist: pyg-lib>=0.4
+Requires-Dist: torch-scatter>=2.1
+Requires-Dist: torch-sparse>=0.6
+Requires-Dist: torch-cluster>=1.6
+Requires-Dist: torch-spline-conv>=1.2
+Requires-Dist: torchdatasets>=0.2
+Requires-Dist: torchmetrics>=1.7
+Requires-Dist: hydra-core>=1.3
+Requires-Dist: einops>=0.8
+Requires-Dist: wandb>=0.21
+Requires-Dist: matplotlib>=3.10
+Requires-Dist: scikit-image>=0.25
+Requires-Dist: opencv-python>=4.12
+Requires-Dist: pandas>=2.3
+Requires-Dist: colorlog>=6.9
+Provides-Extra: cuda128
+Requires-Dist: torch==2.7.1+cu128; extra == "cuda128"
+Requires-Dist: torchvision==0.22.1+cu128; extra == "cuda128"
+Requires-Dist: torchaudio==2.7.1+cu128; extra == "cuda128"
+Requires-Dist: torch-geometric==2.6.1; extra == "cuda128"
+Requires-Dist: pyg-lib==0.4.0+pt27cu128; extra == "cuda128"
+Requires-Dist: torch-scatter==2.1.2+pt27cu128; extra == "cuda128"
+Requires-Dist: torch-sparse==0.6.18+pt27cu128; extra == "cuda128"
+Requires-Dist: torch-cluster==1.6.3+pt27cu128; extra == "cuda128"
+Requires-Dist: torch-spline-conv==1.2.2+pt27cu128; extra == "cuda128"
+
+# SR FORGE
+**Super-Resolution Framework for Oriented Restoration and Guided Enhancement**
+
+---
+
+SR FORGE (**S**uper-**R**esolution **F**ramework for **O**riented **R**estoration & **G**uided **E**nhancement) is a unified, modular, and task-driven framework for training and evaluating deep learning models in the field of super-resolution.
+
+## Key Features
+
+- **Structured Workflow**  
+  SR FORGE provides an **organized** approach to super resolution. Every step—from data loading to final evaluation—follows a clear, modular structure.
+
+- **Task-driven restoration**  
+  Built-in utilities to help fine-tune models for specific tasks or objectives (e.g., OCR, remote sensing, medical imaging, etc.).
+
+- **Config-Driven Experiments**  
+  Simple YAML/JSON configuration files let you customize your pipeline without modifying code directly.
+
+- **Flexible Model Plug-In**  
+  Easily integrate popular SISR (EDSR, RCAN, ESRGAN, etc.) and MISR (RAMS, HighRes-net, PIUNET, TR-MISR, MagNAt) or your own custom architecture.
+
+- **Unified Metrics**  
+  Evaluate your models with a suite of standard metrics (PSNR, SSIM, LPIPS) and straightforward logging.
+
+- **Visualization Tools**  
+  Quickly visualize results (side-by-side comparisons, zoom-ins, or overlays) for interpretability and debugging.
+
+## Installation
+
+1. **Clone the Repository**
+   ```bash
+   git clone https://github.com/your-username/sr-forge.git

srforge-0.1.0/srforge.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+scripts/__init__.py
+scripts/test.py
+scripts/train.py
+srforge/__init__.py
+srforge/registry.py
+srforge/structs.py
+srforge.egg-info/PKG-INFO
+srforge.egg-info/SOURCES.txt
+srforge.egg-info/dependency_links.txt
+srforge.egg-info/entry_points.txt
+srforge.egg-info/requires.txt
+srforge.egg-info/top_level.txt

srforge-0.1.0/srforge.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

srforge-0.1.0/srforge.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+test = scripts.test:main
+train = scripts.train:main

srforge-0.1.0/srforge.egg-info/requires.txt

@@ -0,0 +1,30 @@
+torch>=2.7
+torchvision>=0.22
+torchaudio>=2.7
+torch-geometric>=2.6
+pyg-lib>=0.4
+torch-scatter>=2.1
+torch-sparse>=0.6
+torch-cluster>=1.6
+torch-spline-conv>=1.2
+torchdatasets>=0.2
+torchmetrics>=1.7
+hydra-core>=1.3
+einops>=0.8
+wandb>=0.21
+matplotlib>=3.10
+scikit-image>=0.25
+opencv-python>=4.12
+pandas>=2.3
+colorlog>=6.9
+
+[cuda128]
+torch==2.7.1+cu128
+torchvision==0.22.1+cu128
+torchaudio==2.7.1+cu128
+torch-geometric==2.6.1
+pyg-lib==0.4.0+pt27cu128
+torch-scatter==2.1.2+pt27cu128
+torch-sparse==0.6.18+pt27cu128
+torch-cluster==1.6.3+pt27cu128
+torch-spline-conv==1.2.2+pt27cu128

srforge-0.1.0/srforge.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+scripts
+srforge