Rotation-Equivariant Self-Supervised Method
in Image Denoising

🌀 AdaReNet · CVPR 2025
Hanze Liu · Jiahong Fu · Qi Xie · Deyu Meng
Official PyTorch Implementation

Abstract · Highlights · Introduction · Architecture · Results · Quick Start

📣 News

• May 26, 2025 — Our paper and official implementation are now available. 🎉

🔬 Abstract

Abstract: Self-supervised image denoising methods have garnered significant research attention in recent years, for this kind of method reduces the requirement of large training datasets. Compared to supervised methods, self-supervised methods rely more on the prior embedded in deep networks themselves. As a result, most of the self-supervised methods are designed with Convolution Neural Networks (CNNs) architectures, which well capture one of the most important image prior, translation equivariant prior. Inspired by the great success achieved by the introduction of translational equivariance, in this paper, we explore the way to further incorporate another important image prior.

Specifically, we first apply high-accuracy rotation equivariant convolution to self-supervised image denoising. Through rigorous theoretical analysis, we have proved that simply replacing all the convolution layers with rotation equivariant convolution layers would modify the network into its rotation equivariant version. To the best of our knowledge, this is the first time that rotation equivariant image prior is introduced to self-supervised image denoising at the network architecture level with a comprehensive theoretical analysis of equivariance errors, which offers a new perspective to the field of self-supervised image denoising.

Moreover, to further improve the performance, we design a new mask mechanism to fusion the output of rotation equivariant network and vanilla CNN-based network, and construct an adaptive rotation equivariant framework. Through extensive experiments on three typical methods, we have demonstrated the effectiveness of the proposed method.

✨ Highlights

Self-supervised denoisers rely heavily on architectural priors because clean targets are unavailable. AdaReNet introduces a rotation-equivariant prior into self-supervised image denoising and adaptively balances it with the representation capacity of a conventional CNN.

🌀 Rotation-aware prior High-accuracy equivariant convolutions bring rotational structure into U-Net-style denoisers.

🎛️ Adaptive fusion A learned spatial mask selects between vanilla and equivariant predictions for each image region.

📐 Theoretical grounding The analysis covers convolution, downsampling, upsampling, and the complete equivariant network.

🔍 Introduction

The comparison below visualizes feature maps from randomly initialized standard and rotation-equivariant CNNs. The equivariant network exposes substantially clearer rotational structure before training, illustrating the architectural prior used by AdaReNet.

_{Equivariance comparison. From left to right: input image, standard CNN response, and rotation-equivariant CNN response.}

🧩 Network Architecture

AdaReNet contains four components: a Vanilla Module, an EQ Module, a spatially adaptive Fusion Module, and a Self-correcting Module. Given an input image $I$, the two restoration branches produce $f_c$ and $f_e$, while the mask $M_f$ controls their spatial contribution:

$$ \hat{I}=M_f\odot f_c+(1-M_f)\odot f_e,\qquad \bar{I}=S_c(\hat{I}). $$

_{AdaReNet architecture. The learned mask combines vanilla and rotation-equivariant predictions before self-correction.}

📊 Experimental Results

Selected Noise2Noise results from the paper are reported as PSNR / SSIM. N2N-EQ+ denotes the adaptive rotation-equivariant model.

Dataset	Noise	N2N	N2N-EQ	N2N-EQ+ (AdaReNet)
Kodak	$\sigma=25$	31.47 / 0.874	31.60 / 0.878	31.72 / 0.880
BSD300	$\sigma=25$	30.18 / 0.869	30.28 / 0.872	30.36 / 0.873
Set14	$\sigma=25$	30.02 / 0.851	30.06 / 0.854	30.19 / 0.855
Kodak	$\sigma=50$	28.29 / 0.778	28.58 / 0.790	28.69 / 0.791
BSD300	$\sigma=50$	27.02 / 0.762	27.24 / 0.771	27.31 / 0.772
Set14	$\sigma=50$	27.16 / 0.768	27.32 / 0.775	27.44 / 0.777

See the paper for the complete Noise2Noise, Noise2Void, R2R, ablation, and equivariance-error evaluations.

🛠️ Quick Start

1. 📦 Installation

git clone https://github.com/liuhanze623/AdaReNet.git
cd AdaReNet

conda create -n adarenet python=3.10 -y
conda activate adarenet
pip install -r requirements.txt

Tip

For GPU training, install the torch and torchvision builds that match your CUDA version from the official PyTorch instructions before running pip install -r requirements.txt.

2. 🗃️ Dataset

Following the paper setup, training uses random $256\times256$ crops from the 50,000 images in the ImageNet validation set. Place training and validation images in flat directories:

data/
├── train/
│   ├── image_00001.png
│   └── ...
└── valid/
    ├── image_00001.png
    └── ...

3. 🧰 Select the Training Variant

The repository contains the vanilla, rotation-equivariant, and adaptive training wrappers. Select the corresponding import near the top of src/train.py:

Variant	Training wrapper	Network
Vanilla N2N	noise2noise_Liu.py	Standard U-Net
N2N-EQ	noise2noise_Liu_Fconv.py	Rotation-equivariant U-Net
AdaReNet / N2N-EQ+	noise2noise_addloss_Liu.py	Adaptive dual-branch network

For AdaReNet, use:

from noise2noise_addloss_Liu import Noise2Noise

4. ⚙️ Training

PYTHONPATH=. CUDA_VISIBLE_DEVICES=0 python src/train.py \
  --train-dir /path/to/data/train \
  --train-size 50000 \
  --valid-dir /path/to/data/valid \
  --valid-size 24 \
  --ckpt-save-path /path/to/checkpoints \
  --nb-epochs 40 \
  --batch-size 4 \
  --loss l2 \
  --noise-type gaussian \
  --noise-param 50 \
  --seed 42 \
  --crop-size 256 \
  --plot-stats \
  --cuda \
  --report-interval 1250

🗂️ Repository Structure

AdaReNet/
├── AdaReNet.py                   # Adaptive dual-branch architecture
├── FCNN_plus.py                  # Rotation-equivariant convolution operators
├── src/
│   ├── train.py                  # Training entry point
│   ├── test.py                   # Evaluation entry point
│   ├── noise2noise_Liu.py        # Vanilla N2N wrapper
│   ├── noise2noise_Liu_Fconv.py  # Rotation-equivariant N2N wrapper
│   └── noise2noise_addloss_Liu.py # AdaReNet wrapper and objective
├── image/                        # Paper figures
└── requirements.txt

📝 Citation

If this work is useful in your research, please cite:

@InProceedings{Liu_2025_CVPR,
    author    = {Liu, Hanze and Fu, Jiahong and Xie, Qi and Meng, Deyu},
    title     = {Rotation-Equivariant Self-Supervised Method in Image Denoising},
    booktitle = {Proceedings of the Computer Vision and Pattern Recognition Conference (CVPR)},
    month     = {June},
    year      = {2025},
    pages     = {12720--12730}
}

🙏 Acknowledgements

This implementation builds on ideas and code from Noise2Noise and the F-Conv rotation-equivariant convolution framework. We thank the open-source community for making reproducible research possible.

---

If you find AdaReNet useful, consider giving the repository a ⭐.