Initial release of DFRNet-v1 Baseline

DFRNet-v1-best_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4493dd1b8398752afa41d7e80222f8ddeacdddf17565e4510ddef510c3bdba18
+size 48661

README.md

@@ -0,0 +1,324 @@
+---
+language:
+- en
+license: mit
+library_name: pytorch
+pipeline_tag: image-to-image
+tags:
+- image-restoration
+- image-denoising
+- super-resolution
+- image-enhancement
+- image-to-image
+- computer-vision
+- deep-learning
+- pytorch
+---
+
+# DFRNet-v1 — Baseline
+
+## Overview
+
+DFRNet-v1 is a lightweight convolutional neural network developed as
+the baseline architecture for the DFRNet image restoration project.
+
+The model is designed as an image-to-image learning system. It accepts
+a three-channel RGB image, transforms it through a convolutional
+encoder, and reconstructs the output at a fixed resolution of
+**640 × 1024 pixels**.
+
+The broader DFRNet project explores deep learning approaches for:
+
+- Image restoration
+- Image denoising
+- Image enhancement
+- Resolution enhancement
+- Super-resolution
+
+This release represents the initial baseline architecture and provides
+a reference point for future architectural experiments.
+
+---
+
+## How It Works
+
+The model follows a simple encoder-decoder pipeline:
+
+    Input RGB Image
+            |
+            v
+    Convolutional Encoder
+            |
+            v
+    Feature Transformation
+            |
+            v
+    Bilinear Upsampling
+            |
+            v
+    Output Image
+    640 × 1024
+
+The encoder extracts and transforms visual features using convolutional
+layers. The decoder then uses bilinear interpolation to reconstruct the
+three-channel representation at the required output resolution.
+
+---
+
+## Architecture
+
+The model contains two main components:
+
+### Encoder
+
+The encoder progressively transforms the channel representation:
+
+    3 → 9 → 27 → 3
+
+It consists of:
+
+1. ConvBlock: 3 → 9 channels
+2. ConvBlock: 9 → 27 channels
+3. Conv2D: 27 → 3 channels
+
+Each ConvBlock follows:
+
+    Conv2D (3×3)
+        |
+       ReLU
+        |
+    Conv2D (3×3)
+        |
+       ReLU
+
+All convolutional layers use 3×3 kernels with padding=1, preserving
+the spatial dimensions during convolution.
+
+### Decoder
+
+The decoder uses bilinear interpolation:
+
+    Output resolution: 640 × 1024
+
+The decoder contains no additional learnable parameters.
+
+---
+
+## Model Statistics
+
+| Property | Value |
+|---|---|
+| Architecture | ImageRegressionNet |
+| Framework | PyTorch |
+| Input Channels | 3 |
+| Channel Progression | 3 → 9 → 27 → 3 |
+| Activation | ReLU |
+| Convolution Kernel | 3×3 |
+| Decoder | Bilinear Upsampling |
+| Output Resolution | 640 × 1024 |
+| Total Parameters | 10,524 |
+| Trainable Parameters | 10,524 |
+
+---
+
+## Repository Contents
+
+    DFRNet-v1-Baseline/
+    │
+    ├── DFRNet-v1-best_model.pth
+    │   Trained PyTorch model weights
+    │
+    ├── model.py
+    │   Complete model architecture
+    │
+    ├── architecture.txt
+    │   Detailed architecture explanation
+    │
+    ├── model_summary.txt
+    │   Layer-by-layer model summary
+    │
+    ├── requirements.txt
+    │   Required dependencies
+    │
+    └── README.md
+        Model documentation
+
+---
+
+## Installation
+
+Install the required dependencies:
+
+    pip install -r requirements.txt
+
+---
+
+## Loading the Model
+
+```python
+import torch
+
+from model import ImageRegressionNet
+
+
+device = torch.device(
+    "cuda" if torch.cuda.is_available() else "cpu"
+)
+
+model = ImageRegressionNet().to(device)
+
+checkpoint = torch.load(
+    "DFRNet-v1-best_model.pth",
+    map_location=device
+)
+
+model.load_state_dict(checkpoint)
+
+model.eval()
+````
+
+---
+
+## Basic Inference
+
+```python
+with torch.no_grad():
+    output = model(input_tensor)
+```
+
+The model expects an input tensor in the format:
+
+```
+[B, 3, H, W]
+```
+
+where:
+
+* B is the batch size
+* 3 represents RGB channels
+* H is the image height
+* W is the image width
+
+The output shape is:
+
+```
+[B, 3, 640, 1024]
+```
+
+---
+
+## Important: Preprocessing
+
+For reliable inference, the preprocessing pipeline should match the
+pipeline used during training.
+
+Important considerations include:
+
+* Image resizing
+* RGB channel ordering
+* Tensor conversion
+* Pixel scaling
+* Normalization
+
+Using a significantly different preprocessing pipeline may affect
+model performance.
+
+---
+
+## Intended Use
+
+DFRNet-v1 is intended primarily for:
+
+* Academic experimentation
+* Deep learning research
+* Image restoration experiments
+* Image denoising experiments
+* Image-to-image regression research
+* Architecture experimentation
+
+This version should be considered a baseline research model.
+
+---
+
+## Limitations
+
+DFRNet-v1 is intentionally lightweight and designed as an initial
+baseline architecture.
+
+Limitations include:
+
+* Limited representational capacity compared with deeper models
+* Dependence on the training data distribution
+* Limited generalization to unseen degradation patterns
+* No residual connections
+* No skip connections
+* No multi-scale feature extraction
+* No attention mechanisms
+
+These limitations provide opportunities for future versions of DFRNet.
+
+---
+
+## Future Directions
+
+Future versions may explore:
+
+* Residual learning
+* Skip connections
+* Multi-scale feature extraction
+* Attention mechanisms
+* Improved encoder-decoder architectures
+* Improved reconstruction losses
+* Perceptual losses
+* Advanced denoising strategies
+* Improved super-resolution approaches
+
+---
+
+## Project Philosophy
+
+DFRNet is an iterative deep learning experimentation project.
+
+The objective is not only to develop increasingly capable image
+restoration models, but also to document the technical journey behind
+their development.
+
+This includes:
+
+* Architectural decisions
+* Baseline experiments
+* Model behaviour
+* Failure cases
+* Architectural modifications
+* Experimental comparisons
+* Performance improvements
+* Lessons learned
+
+Each version of DFRNet represents a stage in this ongoing development
+and experimentation process.
+
+---
+
+## Version
+
+**DFRNet-v1 — Baseline**
+
+---
+
+## Author
+
+**Indranil Bhattacharyya**
+
+Independent deep learning research and experimentation project focused
+on image restoration, denoising, and resolution enhancement.
+
+---
+
+## Disclaimer
+
+This model is provided primarily for research, educational, and
+experimental purposes.
+
+Performance may vary depending on the characteristics of the input
+images, degradation patterns, preprocessing pipeline, and similarity
+between inference data and the training distribution.

architecture.txt

@@ -0,0 +1,141 @@
+DFRNet-v1 Baseline
+==================
+
+OVERVIEW
+--------
+
+DFRNet-v1 is a lightweight convolutional image-to-image network
+developed as a baseline for image restoration experiments.
+
+The model takes an RGB image as input and transforms it through
+convolutional feature extraction layers.
+
+The encoder progressively changes the channel representation:
+
+    RGB Input
+        3 channels
+            |
+            v
+        9 channels
+            |
+            v
+        27 channels
+            |
+            v
+        3 channels
+
+The resulting three-channel representation is passed to the decoder.
+
+The decoder uses bilinear interpolation to resize the output to:
+
+    Height: 640 pixels
+    Width:  1024 pixels
+
+
+ARCHITECTURE
+------------
+
+Input RGB Image
+        |
+        v
+
+Encoder
+    |
+    +-- ConvBlock: 3 -> 9
+    |
+    +-- ConvBlock: 9 -> 27
+    |
+    +-- Conv2D: 27 -> 3
+
+        |
+        v
+
+Decoder
+    |
+    +-- Bilinear Upsampling
+        Output: 640 x 1024
+
+        |
+        v
+
+Reconstructed Output Image
+
+
+CONVBLOCK
+---------
+
+Each ConvBlock contains:
+
+    Conv2D (3x3)
+        |
+        v
+    ReLU
+        |
+        v
+    Conv2D (3x3)
+        |
+        v
+    ReLU
+
+
+MODEL STATISTICS
+----------------
+
+Total Parameters:
+    10,524
+
+Trainable Parameters:
+    10,524
+
+
+PYTORCH MODEL
+-------------
+
+ImageRegressionNet(
+  (encoder): Encoder(
+    (stage_1): ConvBlock(
+      (block): Sequential(
+        (0): Conv2d(3, 9, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+        (1): ReLU(inplace=True)
+        (2): Conv2d(9, 9, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+        (3): ReLU(inplace=True)
+      )
+    )
+    (stage_2): ConvBlock(
+      (block): Sequential(
+        (0): Conv2d(9, 27, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+        (1): ReLU(inplace=True)
+        (2): Conv2d(27, 27, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+        (3): ReLU(inplace=True)
+      )
+    )
+    (stage_3): Conv2d(27, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+  )
+  (decoder): Decoder(
+    (upsample_block): Upsample(size=(640, 1024), mode='bilinear')
+  )
+  (encoder_decoder): Sequential(
+    (0): Encoder(
+      (stage_1): ConvBlock(
+        (block): Sequential(
+          (0): Conv2d(3, 9, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+          (1): ReLU(inplace=True)
+          (2): Conv2d(9, 9, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+          (3): ReLU(inplace=True)
+        )
+      )
+      (stage_2): ConvBlock(
+        (block): Sequential(
+          (0): Conv2d(9, 27, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+          (1): ReLU(inplace=True)
+          (2): Conv2d(27, 27, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+          (3): ReLU(inplace=True)
+        )
+      )
+      (stage_3): Conv2d(27, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+    )
+    (1): Decoder(
+      (upsample_block): Upsample(size=(640, 1024), mode='bilinear')
+    )
+  )
+)

model.py

@@ -0,0 +1,94 @@
+
+import torch
+import torch.nn as nn
+
+
+class ConvBlock(nn.Module):
+
+    def __init__(self, in_channels, out_channels):
+        super().__init__()
+
+        self.block = nn.Sequential(
+            nn.Conv2d(
+                in_channels,
+                out_channels,
+                kernel_size=3,
+                padding=1
+            ),
+            nn.ReLU(inplace=True),
+
+            nn.Conv2d(
+                out_channels,
+                out_channels,
+                kernel_size=3,
+                padding=1
+            ),
+            nn.ReLU(inplace=True)
+        )
+
+    def forward(self, x):
+        return self.block(x)
+
+
+class Encoder(nn.Module):
+
+    def __init__(self):
+        super().__init__()
+
+        self.stage_1 = ConvBlock(
+            in_channels=3,
+            out_channels=9
+        )
+
+        self.stage_2 = ConvBlock(
+            in_channels=9,
+            out_channels=27
+        )
+
+        self.stage_3 = nn.Conv2d(
+            in_channels=27,
+            out_channels=3,
+            kernel_size=3,
+            padding=1
+        )
+
+    def forward(self, x):
+
+        x = self.stage_1(x)
+        x = self.stage_2(x)
+        x = self.stage_3(x)
+
+        return x
+
+
+class Decoder(nn.Module):
+
+    def __init__(self):
+        super().__init__()
+
+        self.upsample_block = nn.Upsample(
+            size=(640, 1024),
+            mode="bilinear",
+            align_corners=False
+        )
+
+    def forward(self, x):
+        return self.upsample_block(x)
+
+
+class ImageRegressionNet(nn.Module):
+
+    def __init__(self):
+        super().__init__()
+
+        self.encoder = Encoder()
+
+        self.decoder = Decoder()
+
+        self.encoder_decoder = nn.Sequential(
+            self.encoder,
+            self.decoder
+        )
+
+    def forward(self, x):
+        return self.encoder_decoder(x)

model_summary.txt

@@ -0,0 +1,22 @@
+==========================================================================================
+Layer (type:depth-idx)                   Output Shape              Param #
+==========================================================================================
+ImageRegressionNet                       [1, 3, 640, 1024]         --
+├─Sequential: 1-1                        [1, 3, 640, 1024]         --
+│    └─Encoder: 2-1                      [1, 3, 640, 1024]         --
+│    │    └─ConvBlock: 3-1               [1, 9, 640, 1024]         990
+│    │    └─ConvBlock: 3-2               [1, 27, 640, 1024]        8,802
+│    │    └─Conv2d: 3-3                  [1, 3, 640, 1024]         732
+│    └─Decoder: 2-2                      [1, 3, 640, 1024]         --
+│    │    └─Upsample: 3-4                [1, 3, 640, 1024]         --
+==========================================================================================
+Total params: 10,524
+Trainable params: 10,524
+Non-trainable params: 0
+Total mult-adds (Units.GIGABYTES): 6.90
+==========================================================================================
+Input size (MB): 7.86
+Forward/backward pass size (MB): 393.22
+Params size (MB): 0.04
+Estimated Total Size (MB): 401.12
+==========================================================================================

requirements.txt

@@ -0,0 +1,4 @@
+torch>=2.0.0
+torchvision>=0.15.0
+numpy
+Pillow