initial commit

Author: Pythonista7

DnCNN.py

@@ -0,0 +1,45 @@
+import tensorflow as tf 
+"""
+https://danijar.com/structuring-models/
+"""
+
+class DnCNN(tf.keras.Model):
+  
+    def __init__(self,depth = 5,grayscale=True):
+        super(DnCNN,self).__init__()
+        # Network params
+        self.channels = 1 if grayscale else 3
+        self.depth = depth
+
+    def call(self,input_tensor,training=True):
+        # First Convolution Layer with Conv and ReLU
+        x = tf.keras.layers.Conv2D(64,(3,3),padding="same",kernel_initializer='Orthogonal')(input_tensor)
+        x = tf.keras.activations.relu(x)
+
+        # Add Conv+Batch_Norm+ReLU for layers 2 to (depth-1)
+        for _ in range(self.depth - 1):
+            x = tf.keras.layers.Conv2D(64,(3,3),padding="same",kernel_initializer='Orthogonal')(x)
+            x =  tf.keras.layers.BatchNormalization(epsilon=0.0001)(x,training=training)
+            x = tf.keras.activations.relu(x)
+
+        # The final conv layer will use only 1 filter to recontruct the original image
+        x = tf.keras.layers.Conv2D(1,(3,3),padding="same",kernel_initializer='Orthogonal')(x)
+
+        # Subtract the predicted noise from the noisy input image
+        x = tf.keras.layers.Subtract()([input_tensor,x]) #input - noise
+
+        return x
+    
+    def model(self):
+        # Funtion to build the model
+        x = tf.keras.Input(shape=(None,None,self.channels))
+        return tf.keras.Model(inputs=[x],outputs= self.call(x) )
+
+
+
+
+# Simple code to instantiate , compile and print the summary of the model architecture 
+# if __name__ == "__main__":
+#     model = DnCNN(depth=5).model()
+#     model.compile(optimizer='Adam',loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True),metrics=["accuracy"])
+#     print(model.summary())

README.md

@@ -0,0 +1,27 @@
+# Deep Denoise
+
+This is a tensorflow-2 implementation of the paper [Beyond a Gaussian Denoiser: Residual Learning ofDeep CNN for Image Denoising](https://arxiv.org/pdf/1608.03981.pdf).
+
+### Dataset used : 
+[BSDS200](https://www2.eecs.berkeley.edu/Research/Projects/CS/vision/bsds/BSDS300-images.tgz)
+
+To download and unpack run:
+
+`wget https://www2.eecs.berkeley.edu/Research/Projects/CS/vision/bsds/BSDS300-images.tgz`
+
+`tar -xvzf BSDS300-images.tgz` 
+
+### Requriments : 
+* tensorflow==2.3.1
+* matplotlib
+* numpy
+
+### Run Model
+Run train_denoise.py
+
+### Results
+After training by setting depth=5 for 25 epoch we get the below results. The original paper suggests a deeper architecture feel free to tweak the hyper params in the [train_denoise.py](train_denoise.py) file.
+
+![alt](res1.png)
+
+![alt](res2.png)

deepDenoise.txt

@@ -0,0 +1,78 @@
+
+NOTES
+
+Reading the paper : Beyond a Gaussian Denoiser:Residual Learning of Deep CNN for image denoising.
+
+GOAL of image denoising :
+Derive a clean image x from a noisy image y which follows a degradation model : y = x + v ; v = noise
+
+Aim is to implicitly remove the clean image and learn v . 
+
+This can also be used in image super resolution problem where can see v to be the difference between the 
+groud truth high res image and the bicubic upsampling of a low resolution image , similarly JPEG image 
+deblocking problem can also be solved by taking v as the difference between the original image and the
+compressed image.
+
+Section III
+============
+Proposed model :
+ training a Deep CNN involves 2 tasks: 
+    > Network architecture and design
+    > Model learning and training data ( adopt Residual-Learning with batch normalization )
+
+A. Network Depth
+-----------------
+    > filter size : 3 x 3 and remove all pooling layers
+    > Receptive field of DnCNN of depth d should be (2d + 1) x (2d + 1)  // why ? what is this ?
+
+B. Network Architecture
+-----------------------
+    Generally Denoising algorithms tend to try to learn a mapping function such as F(y) = x to learn the 
+clean image x , but here we adopt residual learning , we want to map R(y) = v and then we can get the clean
+image by doing: x = y - R(y)
+
+LOSS FUNCTION : averaged mean square error between the desired residual image and estimated ones from noisy input
+
+Given we have a net of depth D we are gonna have 3 types of layers :
+    1) Conv + Relu : 
+        > This is the first layer 
+        > has 64 filters of (3 x 3 x c)
+
+    2) Conv + BN + Relu :
+        > from layer 2 till layer (D-1)
+        > 64 filters of size (3 x 3)
+        > do Batch Norm after Conv and before ReLU
+    
+    3) Conv
+        > Last Later
+        > 'c' number of filters of size (3 x 3 x 64) is used to recostruct the output
+
+    * Reducing Boundry artifacts
+        > zero pad intermediate layers so as to retain the original size as input image
+
+EXPERIMENTAL RESULTS AS MENTIONED BY THE AUTHORS OF THE PAPER
+> Training and Testing Data:
+    TRAIN
+        DnCNN-S (S for specific noise level)
+        > 400 images of 180 x 180 for training
+        > considered noise levels of sigma = 15,25,50
+        > patch size = (40 x 40)
+        > crop = (128 x 1)
+        > 600 patches to train the model
+
+        DnCNN-B (B for blind noise level)
+        > noise levels sigma = [0,55]
+        > patch size = (50 x 50)
+        > crop = (128 x 3000)
+    
+    > data-augmentation : rotate/flip pairs within mini-batch
+    
+    > depth = 17(DnCNN-S) , 20 (DnCNN-B)
+
+    > SGD with decay = 0.0001 , momentum = 0.9 , mini-batch size =128
+
+    >epoch = 50
+
+    > lr = 1e-1 to 1e-4 over the 50 epoch
+
+

res1.png

@@ -0,0 +1,66 @@
+"""
+Learnt a lot about building the input pipeline in tf2 from here
+https://financial-engineering.medium.com/tensorflow-2-0-load-images-to-tensorflow-897b8b067fc2
+
+"""
+import matplotlib.pyplot as plt
+import tensorflow as tf
+import numpy as np
+from DnCNN import DnCNN
+
+data_dir = "./BSDS300/images/"
+
+BATCH_SIZE = 32
+IMG_HEIGHT = 321
+IMG_WIDTH = 481
+
+CHANNELS = 1
+
+
+def decode_img(img,channels):
+    img = tf.image.decode_jpeg(img, channels=channels) #color/greyscale images
+    img = tf.image.convert_image_dtype(img, tf.float32) 
+    #convert unit8 tensor to floats in the [0,1]range
+    return tf.image.resize(img, [IMG_WIDTH, IMG_HEIGHT]) 
+
+def process_path(file_path):
+    clean_img = tf.io.read_file(file_path)
+    clean_img = decode_img(clean_img,1) #Setting CHANNELS=1 
+    noisy_img = clean_img + np.random.normal(0,25/255.0,size=clean_img.shape)
+    return noisy_img, clean_img
+
+
+
+# Incase u dont have the dataset you can get it by running the following 2 commands in the dir of this file
+# wget https://www2.eecs.berkeley.edu/Research/Projects/CS/vision/bsds/BSDS300-images.tgz
+# tar -xvzf BSDS300-images.tgz 
+
+# Setup data by reading files for input and testing 
+train_list_ds = tf.data.Dataset.list_files(str(data_dir+'train/*'))
+test_list_ds = tf.data.Dataset.list_files(str(data_dir+'test/*'))
+
+# Load up the files for the model
+train_ds = train_list_ds.map(process_path)
+test_ds = test_list_ds.map(process_path)
+
+# Build the model , compile and fit it to the data
+model = DnCNN(depth=5).model()
+
+opt = tf.keras.optimizers.Adam(lr=0.0001,beta_1=0.9)
+loss_fn = tf.losses.mse
+
+model.compile(optimizer= opt,loss=loss_fn,metrics=["accuracy"])
+
+model.fit(train_ds,epochs=1,batch_size=32)
+
+# Lets now see how the model performs
+test_noise,test_clean = next(iter(test_ds)) #Picking up a sample from test set
+# Make a prediction using the model
+prediction = model.predict(test_noise)
+
+#Plotting out all the 3 images
+fig, (ax1, ax2,ax3) = plt.subplots(1,3,figsize=(7,7))
+fig.suptitle('1) Clean img 2) input noisy img  3) Model output' )
+ax1.imshow( test_clean.numpy().reshape((test_noise.shape[0],test_noise.shape[1])) , cmap = 'gray')
+ax2.imshow(test_noise.numpy().reshape((test_noise.shape[0],test_noise.shape[1])) ,  cmap='gray')
+ax3.imshow(prediction.reshape((prediction.shape[0],prediction.shape[1])),cmap='gray', )