First

app.py

@@ -0,0 +1,41 @@
+""" Import Libraries """
+import torch
+import torch.nn as nn
+from model import Generator
+
+import albumentations as A
+from albumentations.pytorch import ToTensorV2
+import numpy as np
+
+import gradio as gr
+
+""" Loading Model """
+state_dict_path = 'gen_monet_dict.pth'
+model = Generator(3)
+model.load_state_dict(torch.load(state_dict_path, map_location=torch.device('cpu')))
+
+""" Init Transform """
+augment = A.Compose([
+    A.Resize(width=256, height=256),
+    A.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], max_pixel_value=255.0),
+    ToTensorV2()
+])
+
+def main(image):
+    augmented = augment(image=image)
+    tensor_img = augmented['image']
+
+    with torch.inference_mode():
+        pred = model(tensor_img.unsqueeze(0))
+        pred = pred.squeeze(0).permute(1, 2, 0) * 0.5 + 0.5
+
+    return np.array(pred)
+
+app = gr.Interface(
+    fn=main,
+    inputs=gr.Image(),
+    outputs=gr.Image(),
+    examples=['2.jpeg', '4.jpg', '5.jpeg', '6.jpg']
+)
+
+app.launch()

gen_monet_dict.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:773a0b93c5338a229b3627bc3c8523731a813e91471f4ee67bc6fb8de6ff9827
+size 45532978

model.py

@@ -0,0 +1,76 @@
+import torch
+import torch.nn as nn
+
+class DownConv(nn.Module):
+    def __init__(self, in_filters, out_filters):
+        super().__init__()
+        self.block = nn.Sequential(
+            nn.Conv2d(in_filters, out_filters, kernel_size=3, stride=2, padding=1, padding_mode='reflect'),
+            nn.InstanceNorm2d(out_filters),
+            nn.ReLU(inplace=True)
+        )
+        
+    def forward(self, x):
+        return self.block(x)
+    
+class UpConv(nn.Module):
+    def __init__(self, in_filters, out_filters):
+        super().__init__()
+        self.block = nn.Sequential(
+            nn.ConvTranspose2d(in_filters, out_filters, kernel_size=3, stride=2, padding=1, output_padding=1),
+            nn.InstanceNorm2d(out_filters),
+            nn.ReLU(inplace=True)
+        )
+        
+    def forward(self, x):
+        return self.block(x)
+        
+class ResBlock(nn.Module):
+    def __init__(self, channels):
+        super().__init__()
+        self.block = nn.Sequential(
+            nn.ReflectionPad2d(1),
+            nn.Conv2d(channels, channels, 3),
+            nn.InstanceNorm2d(channels),
+            nn.ReLU(inplace=True),
+            nn.ReflectionPad2d(1),
+            nn.Conv2d(channels, channels, 3),
+            nn.InstanceNorm2d(channels)
+        )
+        
+    def forward(self, x):
+        return x + self.block(x)
+
+class Generator(nn.Module):
+    def __init__(self, img_channels, num_res=9):
+        super().__init__()
+        self.conv_1 = nn.Sequential(
+            nn.Conv2d(img_channels, out_channels=64, kernel_size=7, padding=3, padding_mode='reflect'),
+            nn.InstanceNorm2d(64),
+            nn.ReLU(inplace=True))
+        
+        # Downsampling
+        self.down = nn.Sequential(
+            DownConv(64, 128),
+            DownConv(128, 256))
+        
+        # Residual Blocks
+        layers = []
+        for _ in range(num_res):
+            layers.append(ResBlock(256))
+        self.bottleneck = nn.Sequential(*layers)
+        
+        # Upsampling
+        self.up = nn.Sequential(
+            UpConv(256, 128),
+            UpConv(128, 64))
+        
+        self.conv_2 = nn.Conv2d(64, img_channels, kernel_size=7, stride=1, padding=3, padding_mode='reflect')
+    
+    def forward(self, x):
+        x = self.conv_1(x)
+        x = self.down(x)
+        x = self.bottleneck(x)
+        x = self.up(x)      
+        x = self.conv_2(x)   
+        return torch.tanh(x)

requirements.txt

@@ -0,0 +1,4 @@
+torch
+albumentations
+numpy
+gradio