How mingyuliu1/liednet works
Project type and purpose
• This is a research‐oriented deep-learning framework (full-stack ML pipeline) for low-light image enhancement and deblurring.
• It provides both training and inference entry points (train_llie.py, train_lolblur.py, inference_llie.py, inference_lol_blur.py) and evaluation scripts (calculate_pair.py, calculate_unpair.py).
• The core functionality lives in the basicsr Python package, extended here with the LIEDNet architecture (VSSM, LFM, DGDFFN).
File structure
• Top-level scripts & YAML configs
• train_llie.py, train_lolblur.py (training)
• inference_llie.py, inference_lol_blur.py (inference)
• calculate_pair.py, calculate_unpair.py (evaluation)
• options/*.yml (dataset/training configurations)
• Core library (basicsr/)
• archs/ – network definitions and utilities (csm_triton, csms6s, vmamba, zerodce, vgg, discriminator)
• data/ – dataset classes, samplers, degradations, transforms, dataloader
• losses/ – loss functions and helpers
• metrics/ – PSNR/SSIM, LPIPS, unpaired metrics
• models/ – base_model.py, lr_scheduler.py, liednet_model.py
• ops/ – custom CUDA kernels for performance (deform conv, fused act, upfirdn2d)
• transform/ – RGB data transformations
• utils/ – distributed training, downloading, file I/O, logging, options parsing, registry, etc.
• warmup_scheduler/ – warm-up LR scheduling scripts
• Setup & dependencies
• basicsr/setup.py for pip install -e .
• requirements.txt (PyTorch, CUDA≥11.6, other Python libs)
• kernels/ for compiling VSSM-specific CUDA kernels
Readme insights
• Confirms end-to-end LIEDNet framework with three modules: Visual State Space Module (VSSM), Local Feature Module (LFM), Dual Gated-Dconv Feedforward Network (DGDFFN).
• Training recipes for multiple datasets (LOL-Blur, LOL-v1, v2, FiveK).
• Inference and evaluation workflows.
a. Main components
1. CLI Entrypoints
• Training (train_llie.py, train_lolblur.py)
• Inference (inference_llie.py, inference_lol_blur.py)
• Evaluation (calculate_pair.py, calculate_unpair.py)
2. Configuration Manager
• Parses YAML options (options/*.yml via basicsr/utils/options.py)
3. Data Pipeline
• Dataset loader (LOL-Blur, LLIE datasets)
• Data transforms, degradations, batching (data/, transform/)
4. Core Model
• LIEDNet assembled from archs/ modules (VSSM, LFM, DGDFFN)
• BaseModel wrapper (models/base_model.py)
5. Custom Operations
• CUDA kernels (ops/dcn, ops/fused_act, ops/upfirdn2d)
6. Training Engine
• Optimizer + learning-rate scheduler (models/lr_scheduler.py, warmup_scheduler/)
• Loss computation (losses/)
• Backprop and parameter updates
7. Metrics & Evaluation
• Paired metrics (PSNR, SSIM, LPIPS)
• Unpaired metrics (MUSIQ, NRQM, NIQE)
8. Utilities
• Logging, checkpointing (utils/logger.py, utils/misc.py)
• Distributed training helpers (utils/dist_util.py)
• Download & registry (utils/download_util.py, utils/registry.py)
9. External Resources
• Disk I/O (datasets, pretrained models, output images)
• GPU devices (CUDA runtime)
b. Relationships and interactions
• User invokes a CLI script → Configuration Manager loads options → Data Pipeline yields batches → Core Model (with Custom Ops) processes inputs → Training Engine applies Loss → Optimizer updates Model → Metrics computed → Results and logs saved to disk → (for evaluation) metrics scripts read outputs and ground truth.
• Inference follows a similar flow without gradient/backprop.
c. Architectural patterns and design principles
• Modular separation: each concern (data, model, loss, metrics, ops, utils) in its own package.
• Plugin/registry pattern: options and models registered dynamically.
• Extensibility: new architectures or datasets can be dropped into archs/ or data/.
• High-performance custom CUDA kernels co-located in ops/.
d. Key technologies
• PyTorch (tensor operations, autograd, modules)
• CUDA/C++ (custom kernels)
• YAML for configuration
• Python packaging (setup.py) for easy development install
• Python logging, distributed training utilities