Datasets:

AaronCIH
/

PIR_tar

Modalities:

PIR_tar / scripts /generate_noise.py

Rename generate_noise.py to scripts/generate_noise.py

3fb0bb1 verified about 1 year ago

10.8 kB

import argparse
import glob
import os
from PIL import Image

import cv2
import math
import numpy as np
import os
import os.path as osp
import random
import time
import torch
from tqdm import tqdm

from basicsr.data.degradations import circular_lowpass_kernel, random_mixed_kernels
from basicsr.data.transforms import augment
from basicsr.utils import FileClient, get_root_logger, imfrombytes, img2tensor
from basicsr.utils.registry import DATASET_REGISTRY
from torch.utils import data as data
from torchvision.transforms.functional import center_crop
import torchvision.transforms as T
from torchvision.utils import save_image

from basicsr.data.degradations import random_add_gaussian_noise_pt, random_add_poisson_noise_pt
from basicsr.data.transforms import paired_random_crop
from basicsr.utils import DiffJPEG, USMSharp
from basicsr.utils.img_process_util import filter2D
from basicsr.utils.registry import MODEL_REGISTRY
from collections import OrderedDict
from torch.nn import functional as F

cfg = {
    # dataset info.
    "name": "DF2K+OST",
    "type": "RealESRGANDataset",
    "dataroot_gt": "/home/CORP/hsiang.chen/Project/Datasets/IR/SuperResolution",
    "meta_train": [
                "DIV2K/metas/DIV2K_train_HR.list",
                "Flickr2K/metas/Flickr2K.list",
                # "OST/metas/OST.list",
    ],               
    "meta_test": ["DIV2K/metas/DIV2K_valid_HR.list"],

    # the first degradation process
    "resize_prob": [0.2, 0.7, 0.1],  # up, down, keep
    "resize_range": [0.15, 1.5],
    "gaussian_noise_prob": 0.5,
    "noise_range": [1, 30],
    "poisson_scale_range": [0.05, 3],
    "gray_noise_prob": 0.4,
    "jpeg_range": [30, 95],

    "blur_kernel_size": 21,
    "kernel_list": ['iso', 'aniso', 'generalized_iso', 'generalized_aniso', 'plateau_iso', 'plateau_aniso'],
    "kernel_prob": [0.45, 0.25, 0.12, 0.03, 0.12, 0.03],
    "sinc_prob": 0.1,
    "blur_sigma": [0.2, 3],
    "betag_range": [0.5, 4],
    "betap_range": [1, 2],

    # the second degradation process
    "second_blur_prob": 0.8,
    "resize_prob2": [0.3, 0.4, 0.3],  # up, down, keep
    "resize_range2": [0.3, 1.2],
    "gaussian_noise_prob2": 0.5,
    "noise_range2": [1, 25],
    "poisson_scale_range2": [0.05, 2.5],
    "gray_noise_prob2": 0.4,
    "jpeg_range2": [30, 95],

    "blur_kernel_size2": 21,
    "kernel_list2": ['iso', 'aniso', 'generalized_iso', 'generalized_aniso', 'plateau_iso', 'plateau_aniso'],
    "kernel_prob2": [0.45, 0.25, 0.12, 0.03, 0.12, 0.03],
    "sinc_prob2": 0.1,
    "blur_sigma2": [0.2, 1.5],
    "betag_range2": [0.5, 4],
    "betap_range2": [1, 2],

    "final_sinc_prob": 0.8,

    "gt_size": 512,
    "keep_ratio": True,
    "use_hflip": True,
    "use_rot": False,

    # data loader
    "use_shuffle": True,
    "num_worker_per_gpu": 5,
    "batch_size_per_gpu": 12,
    "dataset_enlarge_ratio": 1,
    "prefetch_mode": None,
}

def set_seed(seed=42):
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)

    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark = False

@DATASET_REGISTRY.register()
class NoiseDataset(data.Dataset):
    """Dataset used for Denoise model:
    synthetic Gaussian and Poisson noise dataset.
    """
    def __init__(self, opt, train=True, level=None):
        super(NoiseDataset, self).__init__()
        self.opt = opt

        # kernel define
        self.data_rt = opt['dataroot_gt']

        # dataload
        self.train = train
        if self.train:
            self.metas = opt['meta_train']
        else:
            self.metas = opt['meta_test']

        self.paths = []
        for meta in self.metas:
            with open(os.path.join(self.data_rt, meta)) as fin:
                self.paths += [line.strip().split(' ')[1] for line in fin]

        # hyperparameter

        self.device = torch.cuda.current_device()
        self.jpeger = DiffJPEG(differentiable=False).to(self.device)  # simulate JPEG compression artifacts
        self.usm_sharpener = USMSharp().to(self.device)  # do usm sharpening
        self.resize = opt['gt_size']
        self.keep_ratio = opt['keep_ratio']

        # function
        self.crop = T.RandomCrop((self.resize, self.resize))
        self.flip = T.RandomHorizontalFlip()
        self.transform = T.Compose(
            [
                # T.ToDtype(torch.float32, scale=True),  # only support for torch 2.++
                T.ToTensor(),
            ]
        )

        # noise
        self.sigma = [0.0588, 0.0784, 0.098, 0.1451, 0.1961] # 5 levels: 15, 20, 25, 37, 50
        if level:
            self.level = [level]
        else:
            self.level = [1,2,3,4,5]

    def __getitem__(self, index):
        # -------------------------------- Load gt images -------------------------------- #
        gt_path = self.paths[index]
        img_gt = Image.open(gt_path).convert("RGB")

        # -------------------------------- Image Process --------------------------------
        # resize
        h, w = img_gt.height, img_gt.width
        if self.keep_ratio:
            ratio = self.resize / min(h, w)
            h_new, w_new = round(h * ratio * 1.2), round(w * ratio * 1.2)
            img_gt = img_gt.resize((w_new, h_new), resample=Image.LANCZOS)
        else:
            img_gt = img_gt.resize((self.resize, self.resize), resample=Image.LANCZOS)
        # crop and 
        img_gt = self.crop(img_gt)
        # flip (only for train)
        if self.train:
            img_gt = self.flip(img_gt)
        # transform to tensor
        img_gt = self.transform(img_gt).to(torch.float32)

        # -------------------------------- Generate Noise --------------------------------
        # Poisson Noise
        peak = 255
        lam = torch.clamp(img_gt, 0, 1) * peak
        counts = torch.poisson(lam)
        img_poisson = torch.clamp(counts / float(peak), 0.0, 1.0)
        
        # Gaussian Noise
        level = random.choice(self.level)
        noise = torch.randn(size=img_poisson.size())
        img_poisson_gaussian = torch.clamp(img_poisson + self.sigma[level-1] * noise, 0., 1.)

        return img_poisson_gaussian, img_gt, gt_path

    def __len__(self):
        return len(self.paths)

def poisson_gaussian_sampler():
    """
    It is now used for DF2K dataset (DIV2K + Flickr 2K)
    """
    parser = argparse.ArgumentParser()
    parser.add_argument('--level', type=int, default=None, help='train: one to many')
    args = parser.parse_args()

    if args.level:
        level = args.level 
    else:
        level = [1,3,5]

    # generate training dataset
    for number in level:
        print("="*100)
        print(f"Generate Noise Level {number}...")

        dataset = NoiseDataset(cfg, train=True, level=number)
        data_dl = data.DataLoader( 
            dataset,
            batch_size = 1
        )
        print("Train Data:", dataset.data_rt, len(data_dl))
        meta_info = {}
        for sample in tqdm(data_dl):
            lq, hq, path = sample
            # /home/CORP/hsiang.chen/Project/Datasets/IR/SuperResolution/DIV2K/DIV2K_train_HR/0098.png
            file_name = os.path.basename(path[0])
            gt_folder = os.path.dirname(path[0]) # /home/CORP/hsiang.chen/Project/Datasets/IR/SuperResolution/DIV2K/DIV2K_train_HR/
            if "DIV2K_train_HR" in gt_folder or "DIV2K_valid_HR" in gt_folder:
                hq_folder = gt_folder.replace("HR", f"pair/Noise_L{number}/HQ")
                lq_folder = gt_folder.replace("HR", f"pair/Noise_L{number}/LQ")
            else:
                hq_folder = os.path.join(gt_folder.replace("images", f"images_pair/Noise_L{number}"), "HQ/")
                lq_folder = os.path.join(gt_folder.replace("images", f"images_pair/Noise_L{number}"), "LQ/")

            os.makedirs(hq_folder, exist_ok=True)
            os.makedirs(lq_folder, exist_ok=True)

            hq_path = os.path.join(hq_folder, file_name)
            lq_path = os.path.join(lq_folder, file_name)

            save_image(hq[0], hq_path)
            save_image(lq[0], lq_path)

            dset = os.path.relpath(gt_folder, dataset.data_rt).split("/")[0]
            if dset not in meta_info:
                meta_info[dset] = [(lq_path, hq_path)]
            else:
                meta_info[dset].append((lq_path, hq_path))

        for dset, dlist in meta_info.items():
            with open(os.path.join(dataset.data_rt,'{}/metas/{}_train_Noise_L{}.list'.format(dset, dset, number)), 'w') as fp:
                for item in dlist:
                    fp.write('{} {} {}\n'.format(item[0], item[1], None))
            print(os.path.join(dataset.data_rt,'{}/metas/{}_train_Noise_L{}.list'.format(dset, dset, number)), len(dlist))

    # generate testing dataset
    dataset = NoiseDataset(cfg, train=False)
    data_dl = data.DataLoader( 
        dataset,
        batch_size = 1
    )
    print("Test Data:", dataset.data_rt, len(data_dl))
    print("="*100)
    print(f"Generate Testing Noise...")

    meta_info = {}
    for sample in tqdm(data_dl):
        lq, hq, path = sample
        # /home/CORP/hsiang.chen/Project/Datasets/IR/SuperResolution/DIV2K/DIV2K_train_HR/0098.png
        file_name = os.path.basename(path[0])
        gt_folder = os.path.dirname(path[0]) # /home/CORP/hsiang.chen/Project/Datasets/IR/SuperResolution/DIV2K/DIV2K_train_HR/
        if "DIV2K_train_HR" in gt_folder or "DIV2K_valid_HR" in gt_folder:
            hq_folder = gt_folder.replace("HR", f"pair/Noise/HQ")
            lq_folder = gt_folder.replace("HR", f"pair/Noise/LQ")
        else:
            hq_folder = os.path.join(gt_folder.replace("images", f"images_pair/Noise"), "HQ/")
            lq_folder = os.path.join(gt_folder.replace("images", f"images_pair/Noise"), "LQ/")

        os.makedirs(hq_folder, exist_ok=True)
        os.makedirs(lq_folder, exist_ok=True)

        hq_path = os.path.join(hq_folder, file_name)
        lq_path = os.path.join(lq_folder, file_name)

        save_image(hq[0], hq_path)
        save_image(lq[0], lq_path)

        dset = os.path.relpath(gt_folder, dataset.data_rt).split("/")[0]
        if dset not in meta_info:
            meta_info[dset] = [(lq_path, hq_path)]
        else:
            meta_info[dset].append((lq_path, hq_path))

    for dset, dlist in meta_info.items():
        with open(os.path.join(dataset.data_rt,'{}/metas/{}_valid_Noise.list'.format(dset, dset)), 'w') as fp:
            for item in dlist:
                fp.write('{} {} {}\n'.format(item[0], item[1], None))
        print(os.path.join(dataset.data_rt,'{}/metas/{}_valid_Noise.list'.format(dset, dset)), len(dlist))

if __name__ == '__main__':
    set_seed(1229)
    # poisson_gaussian for data generation
    poisson_gaussian_sampler()

# python 3_generate_noise.py

	import argparse
	import glob
	import os
	from PIL import Image

	import cv2
	import math
	import numpy as np
	import os
	import os.path as osp
	import random
	import time
	import torch
	from tqdm import tqdm

	from basicsr.data.degradations import circular_lowpass_kernel, random_mixed_kernels
	from basicsr.data.transforms import augment
	from basicsr.utils import FileClient, get_root_logger, imfrombytes, img2tensor
	from basicsr.utils.registry import DATASET_REGISTRY
	from torch.utils import data as data
	from torchvision.transforms.functional import center_crop
	import torchvision.transforms as T
	from torchvision.utils import save_image

	from basicsr.data.degradations import random_add_gaussian_noise_pt, random_add_poisson_noise_pt
	from basicsr.data.transforms import paired_random_crop
	from basicsr.utils import DiffJPEG, USMSharp
	from basicsr.utils.img_process_util import filter2D
	from basicsr.utils.registry import MODEL_REGISTRY
	from collections import OrderedDict
	from torch.nn import functional as F

	cfg = {
	# dataset info.
	"name": "DF2K+OST",
	"type": "RealESRGANDataset",
	"dataroot_gt": "/home/CORP/hsiang.chen/Project/Datasets/IR/SuperResolution",
	"meta_train": [
	"DIV2K/metas/DIV2K_train_HR.list",
	"Flickr2K/metas/Flickr2K.list",
	# "OST/metas/OST.list",
	],
	"meta_test": ["DIV2K/metas/DIV2K_valid_HR.list"],

	# the first degradation process
	"resize_prob": [0.2, 0.7, 0.1], # up, down, keep
	"resize_range": [0.15, 1.5],
	"gaussian_noise_prob": 0.5,
	"noise_range": [1, 30],
	"poisson_scale_range": [0.05, 3],
	"gray_noise_prob": 0.4,
	"jpeg_range": [30, 95],

	"blur_kernel_size": 21,
	"kernel_list": ['iso', 'aniso', 'generalized_iso', 'generalized_aniso', 'plateau_iso', 'plateau_aniso'],
	"kernel_prob": [0.45, 0.25, 0.12, 0.03, 0.12, 0.03],
	"sinc_prob": 0.1,
	"blur_sigma": [0.2, 3],
	"betag_range": [0.5, 4],
	"betap_range": [1, 2],

	# the second degradation process
	"second_blur_prob": 0.8,
	"resize_prob2": [0.3, 0.4, 0.3], # up, down, keep
	"resize_range2": [0.3, 1.2],
	"gaussian_noise_prob2": 0.5,
	"noise_range2": [1, 25],
	"poisson_scale_range2": [0.05, 2.5],
	"gray_noise_prob2": 0.4,
	"jpeg_range2": [30, 95],

	"blur_kernel_size2": 21,
	"kernel_list2": ['iso', 'aniso', 'generalized_iso', 'generalized_aniso', 'plateau_iso', 'plateau_aniso'],
	"kernel_prob2": [0.45, 0.25, 0.12, 0.03, 0.12, 0.03],
	"sinc_prob2": 0.1,
	"blur_sigma2": [0.2, 1.5],
	"betag_range2": [0.5, 4],
	"betap_range2": [1, 2],

	"final_sinc_prob": 0.8,

	"gt_size": 512,
	"keep_ratio": True,
	"use_hflip": True,
	"use_rot": False,

	# data loader
	"use_shuffle": True,
	"num_worker_per_gpu": 5,
	"batch_size_per_gpu": 12,
	"dataset_enlarge_ratio": 1,
	"prefetch_mode": None,
	}

	def set_seed(seed=42):
	random.seed(seed)
	np.random.seed(seed)
	torch.manual_seed(seed)
	torch.cuda.manual_seed(seed)
	torch.cuda.manual_seed_all(seed)

	torch.backends.cudnn.deterministic = True
	torch.backends.cudnn.benchmark = False

	@DATASET_REGISTRY.register()
	class NoiseDataset(data.Dataset):
	"""Dataset used for Denoise model:
	synthetic Gaussian and Poisson noise dataset.
	"""
	def __init__(self, opt, train=True, level=None):
	super(NoiseDataset, self).__init__()
	self.opt = opt

	# kernel define
	self.data_rt = opt['dataroot_gt']

	# dataload
	self.train = train
	if self.train:
	self.metas = opt['meta_train']
	else:
	self.metas = opt['meta_test']

	self.paths = []
	for meta in self.metas:
	with open(os.path.join(self.data_rt, meta)) as fin:
	self.paths += [line.strip().split(' ')[1] for line in fin]

	# hyperparameter

	self.device = torch.cuda.current_device()
	self.jpeger = DiffJPEG(differentiable=False).to(self.device) # simulate JPEG compression artifacts
	self.usm_sharpener = USMSharp().to(self.device) # do usm sharpening
	self.resize = opt['gt_size']
	self.keep_ratio = opt['keep_ratio']

	# function
	self.crop = T.RandomCrop((self.resize, self.resize))
	self.flip = T.RandomHorizontalFlip()
	self.transform = T.Compose(
	[
	# T.ToDtype(torch.float32, scale=True), # only support for torch 2.++
	T.ToTensor(),
	]
	)

	# noise
	self.sigma = [0.0588, 0.0784, 0.098, 0.1451, 0.1961] # 5 levels: 15, 20, 25, 37, 50
	if level:
	self.level = [level]
	else:
	self.level = [1,2,3,4,5]

	def __getitem__(self, index):
	# -------------------------------- Load gt images -------------------------------- #
	gt_path = self.paths[index]
	img_gt = Image.open(gt_path).convert("RGB")

	# -------------------------------- Image Process --------------------------------
	# resize
	h, w = img_gt.height, img_gt.width
	if self.keep_ratio:
	ratio = self.resize / min(h, w)
	h_new, w_new = round(h * ratio * 1.2), round(w * ratio * 1.2)
	img_gt = img_gt.resize((w_new, h_new), resample=Image.LANCZOS)
	else:
	img_gt = img_gt.resize((self.resize, self.resize), resample=Image.LANCZOS)
	# crop and
	img_gt = self.crop(img_gt)
	# flip (only for train)
	if self.train:
	img_gt = self.flip(img_gt)
	# transform to tensor
	img_gt = self.transform(img_gt).to(torch.float32)

	# -------------------------------- Generate Noise --------------------------------
	# Poisson Noise
	peak = 255
	lam = torch.clamp(img_gt, 0, 1) * peak
	counts = torch.poisson(lam)
	img_poisson = torch.clamp(counts / float(peak), 0.0, 1.0)

	# Gaussian Noise
	level = random.choice(self.level)
	noise = torch.randn(size=img_poisson.size())
	img_poisson_gaussian = torch.clamp(img_poisson + self.sigma[level-1] * noise, 0., 1.)

	return img_poisson_gaussian, img_gt, gt_path

	def __len__(self):
	return len(self.paths)

	def poisson_gaussian_sampler():
	"""
	It is now used for DF2K dataset (DIV2K + Flickr 2K)
	"""
	parser = argparse.ArgumentParser()
	parser.add_argument('--level', type=int, default=None, help='train: one to many')
	args = parser.parse_args()

	if args.level:
	level = args.level
	else:
	level = [1,3,5]

	# generate training dataset
	for number in level:
	print("="*100)
	print(f"Generate Noise Level {number}...")

	dataset = NoiseDataset(cfg, train=True, level=number)
	data_dl = data.DataLoader(
	dataset,
	batch_size = 1
	)
	print("Train Data:", dataset.data_rt, len(data_dl))
	meta_info = {}
	for sample in tqdm(data_dl):
	lq, hq, path = sample
	# /home/CORP/hsiang.chen/Project/Datasets/IR/SuperResolution/DIV2K/DIV2K_train_HR/0098.png
	file_name = os.path.basename(path[0])
	gt_folder = os.path.dirname(path[0]) # /home/CORP/hsiang.chen/Project/Datasets/IR/SuperResolution/DIV2K/DIV2K_train_HR/
	if "DIV2K_train_HR" in gt_folder or "DIV2K_valid_HR" in gt_folder:
	hq_folder = gt_folder.replace("HR", f"pair/Noise_L{number}/HQ")
	lq_folder = gt_folder.replace("HR", f"pair/Noise_L{number}/LQ")
	else:
	hq_folder = os.path.join(gt_folder.replace("images", f"images_pair/Noise_L{number}"), "HQ/")
	lq_folder = os.path.join(gt_folder.replace("images", f"images_pair/Noise_L{number}"), "LQ/")

	os.makedirs(hq_folder, exist_ok=True)
	os.makedirs(lq_folder, exist_ok=True)

	hq_path = os.path.join(hq_folder, file_name)
	lq_path = os.path.join(lq_folder, file_name)

	save_image(hq[0], hq_path)
	save_image(lq[0], lq_path)

	dset = os.path.relpath(gt_folder, dataset.data_rt).split("/")[0]
	if dset not in meta_info:
	meta_info[dset] = [(lq_path, hq_path)]
	else:
	meta_info[dset].append((lq_path, hq_path))

	for dset, dlist in meta_info.items():
	with open(os.path.join(dataset.data_rt,'{}/metas/{}_train_Noise_L{}.list'.format(dset, dset, number)), 'w') as fp:
	for item in dlist:
	fp.write('{} {} {}\n'.format(item[0], item[1], None))
	print(os.path.join(dataset.data_rt,'{}/metas/{}_train_Noise_L{}.list'.format(dset, dset, number)), len(dlist))

	# generate testing dataset
	dataset = NoiseDataset(cfg, train=False)
	data_dl = data.DataLoader(
	dataset,
	batch_size = 1
	)
	print("Test Data:", dataset.data_rt, len(data_dl))
	print("="*100)
	print(f"Generate Testing Noise...")

	meta_info = {}
	for sample in tqdm(data_dl):
	lq, hq, path = sample
	# /home/CORP/hsiang.chen/Project/Datasets/IR/SuperResolution/DIV2K/DIV2K_train_HR/0098.png
	file_name = os.path.basename(path[0])
	gt_folder = os.path.dirname(path[0]) # /home/CORP/hsiang.chen/Project/Datasets/IR/SuperResolution/DIV2K/DIV2K_train_HR/
	if "DIV2K_train_HR" in gt_folder or "DIV2K_valid_HR" in gt_folder:
	hq_folder = gt_folder.replace("HR", f"pair/Noise/HQ")
	lq_folder = gt_folder.replace("HR", f"pair/Noise/LQ")
	else:
	hq_folder = os.path.join(gt_folder.replace("images", f"images_pair/Noise"), "HQ/")
	lq_folder = os.path.join(gt_folder.replace("images", f"images_pair/Noise"), "LQ/")

	os.makedirs(hq_folder, exist_ok=True)
	os.makedirs(lq_folder, exist_ok=True)

	hq_path = os.path.join(hq_folder, file_name)
	lq_path = os.path.join(lq_folder, file_name)

	save_image(hq[0], hq_path)
	save_image(lq[0], lq_path)

	dset = os.path.relpath(gt_folder, dataset.data_rt).split("/")[0]
	if dset not in meta_info:
	meta_info[dset] = [(lq_path, hq_path)]
	else:
	meta_info[dset].append((lq_path, hq_path))

	for dset, dlist in meta_info.items():
	with open(os.path.join(dataset.data_rt,'{}/metas/{}_valid_Noise.list'.format(dset, dset)), 'w') as fp:
	for item in dlist:
	fp.write('{} {} {}\n'.format(item[0], item[1], None))
	print(os.path.join(dataset.data_rt,'{}/metas/{}_valid_Noise.list'.format(dset, dset)), len(dlist))

	if __name__ == '__main__':
	set_seed(1229)
	# poisson_gaussian for data generation
	poisson_gaussian_sampler()

	# python 3_generate_noise.py