add SRGAN

.gitignore

@@ -1,4 +1,5 @@
 models/HAT/__pycache__/hat.cpython-39.pyc
 /.venv
 /models/HAT/__pycache__
-/models/RCAN/__pycache__
+/models/RCAN/__pycache__
+/models/SRGAN/__pycache__

app.py

@@ -5,6 +5,7 @@ from PIL import Image
 from io import BytesIO
 from models.HAT.hat import *
 from models.RCAN.rcan import *
+from models.SRGAN.srgan import *    
 
 # Initialize session state for enhanced images
 if 'hat_enhanced_image' not in st.session_state:
@@ -13,11 +14,17 @@ if 'hat_enhanced_image' not in st.session_state:
 if 'rcan_enhanced_image' not in st.session_state:
     st.session_state['rcan_enhanced_image'] = None
 
+if 'srgan_enhanced_image' not in st.session_state:
+    st.session_state['srgan_enhanced_image'] = None
+
 if 'hat_clicked' not in st.session_state:
     st.session_state['hat_clicked'] = False
 if 'rcan_clicked' not in st.session_state:
     st.session_state['rcan_clicked'] = False
-    
+
+if 'srgan_clicked' not in st.session_state:
+    st.session_state['srgan_clicked'] = False 
+
 st.markdown("<h1 style='text-align: center'>Image Super Resolution</h1>", unsafe_allow_html=True)
 # Sidebar for navigation
 st.sidebar.title("Options")
@@ -38,8 +45,10 @@ elif app_mode == "Take a photo":
 def reset_states():
     st.session_state['hat_enhanced_image'] = None
     st.session_state['rcan_enhanced_image'] = None
+    st.session_state['srgan_enhanced_image'] = None
     st.session_state['hat_clicked'] = False
     st.session_state['rcan_clicked'] = False
+    st.session_state['srgan_clicked'] = False
     
 def get_image_download_link(img, filename):
     """Generates a link allowing the PIL image to be downloaded"""
@@ -93,3 +102,22 @@ if 'image' in locals():
         col2.image(st.session_state['rcan_enhanced_image'], use_column_width=True)
         with col2:
             get_image_download_link(st.session_state['rcan_enhanced_image'], 'rcan_enhanced.jpg')
+    #--------------------------SRGAN--------------------------#
+    if st.button('Enhance with SRGAN'):
+        with st.spinner('Processing using SRGAN...'):
+            with st.spinner('Wait for it... the model is processing the image'):
+                srgan_model = GeneratorResnet()
+                device = torch.device('cpu') if not torch.cuda.is_available() else torch.device('cuda')
+                srgan_model = torch.load('models/SRGAN/srgan_checkpoint.pth', map_location=device)
+                enhanced_image = srgan_model.inference(image)
+                st.session_state['srgan_enhanced_image'] = enhanced_image
+            st.session_state['srgan_clicked'] = True 
+            st.success('Done!')
+    if st.session_state['srgan_enhanced_image'] is not None:
+        col1, col2 = st.columns(2)
+        col1.header("Original")
+        col1.image(image, use_column_width=True)
+        col2.header("Enhanced")
+        col2.image(st.session_state['srgan_enhanced_image'], use_column_width=True)
+        with col2:
+            get_image_download_link(st.session_state['srgan_enhanced_image'], 'srgan_enhanced.jpg')

models/SRGAN/srgan.py

@@ -0,0 +1,73 @@
+import os
+import torch
+from torch import nn
+from PIL import Image
+from torchvision.transforms import ToTensor
+
+class ResidualBlock(nn.Module):
+    def __init__(self, in_features):
+        super(ResidualBlock, self).__init__()
+        self.conv_block = nn.Sequential(
+            nn.Conv2d(in_features, in_features, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(in_features, 0.8),
+            nn.PReLU(),
+            nn.Conv2d(in_features, in_features, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(in_features, 0.8),
+        )
+    
+    def forward(self, x):
+        return x + self.conv_block(x)
+    
+class GeneratorResnet(nn.Module):
+    def __init__(self, in_channels=3, out_channels=3, n_residual_blocks=16):
+        super(GeneratorResnet, self).__init__()
+        #first layer
+        self.conv1 = nn.Sequential(nn.Conv2d(in_channels, 64, kernel_size=9, stride=1, padding=4), nn.PReLU())
+        
+        #Residual blocks
+        res_blocks=[]
+        for _ in range(n_residual_blocks):
+            res_blocks.append(ResidualBlock(64))
+        self.res_blocks = nn.Sequential(*res_blocks)
+        
+        #second conv layer after res blocks
+        self.conv2 = nn.Sequential(nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1), nn.BatchNorm2d(64, 0.8))
+        upsampling=[]
+        for _ in range(2):
+            upsampling+=[
+                nn.Conv2d(64, 256, kernel_size=3, stride=1, padding=1),
+                nn.BatchNorm2d(256),
+                nn.PixelShuffle(upscale_factor=2),
+                nn.PReLU(),
+            ]
+        self.upsampling = nn.Sequential(*upsampling)
+        
+        self.conv3 = nn.Sequential(nn.Conv2d(64, out_channels, kernel_size=9, stride=1, padding=4), nn.Tanh())
+        
+    def forward(self, x):
+        out1 = self.conv1(x)
+        out = self.res_blocks(out1)
+        out2 = self.conv2(out)
+        out = torch.add(out1, out2)
+        out = self.upsampling(out)
+        out = self.conv3(out)
+        return out
+    
+    def inference(self, x):
+        """
+        x is a PIL image
+        """
+        x = ToTensor()(x).unsqueeze(0)
+        x = self.forward(x)
+        x = Image.fromarray((x.squeeze(0).permute(1, 2, 0).detach().numpy() * 255).astype('uint8'))
+        return x
+    
+if __name__ == '__main__':
+    current_dir = os.path.dirname(os.path.realpath(__file__))
+
+    model = GeneratorResnet()
+    model = torch.load(current_dir + '/srgan_checkpoint.pth', map_location=torch.device('cpu'))
+    model.eval()
+    with torch.no_grad():
+        input_image = Image.open('images/demo.png')
+        output_image = model.inference(input_image)

models/SRGAN/srgan_checkpoint.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9b1423b711b26b2250612e02fddf95a4a7214e883c601eb153bfa82caceb5511
+size 6336189