Uploading the model to huggingface

app.py

@@ -0,0 +1,38 @@
+import streamlit as st
+from helper import *
+
+# Set the page title
+st.title("Aging Deaging - Assignment 4")
+
+# Create columns for input and output sections
+col1, col2 = st.columns(2)
+
+# Input Section
+with col1:
+    st.header("Input")
+    uploaded_image = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png"])
+    
+    if uploaded_image is not None:
+        # Display the uploaded image
+        st.image(uploaded_image, caption="Uploaded Image")
+
+        # Display the selected option
+        
+
+# Output Section
+with col2:
+    st.header("Output")
+    age_conversion_option = st.radio("Select age conversion option", ("Old to Young", "Young to Old"))
+    st.write(f"Selected conversion: {age_conversion_option}")
+    if st.button("Generate"):
+        if uploaded_image is not None:
+            # Here you can add your image processing code
+            # For now, we'll just display the uploaded image as a placeholder
+            if age_conversion_option == "Young to Old":
+                processed_image = generate_Y2O(uploaded_image)
+                st.image(processed_image, caption="Old you", use_column_width=True)
+            elif age_conversion_option == "Old to Young":
+                processed_image = generate_O2Y(uploaded_image)
+                st.image(processed_image, caption="Young you", use_column_width=True)
+        else:
+            st.warning("Please upload an image before clicking Generate")

helper.py

@@ -0,0 +1,125 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import cv2
+from torchvision import transforms,datasets
+from PIL import Image
+input_nc = 3
+output_nc = 3
+class SEBlock(nn.Module):
+    def __init__(self, channel, reduction=16):
+        super(SEBlock, self).__init__()
+        self.fc = nn.Sequential(
+            nn.AdaptiveAvgPool2d(1),  # Squeeze: output size (N, channel, 1, 1)
+            nn.Conv2d(channel, channel // reduction, 1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(channel // reduction, channel, 1),
+            nn.Sigmoid()  # Excitation: channel weights between 0 and 1
+        )
+    
+    def forward(self, x):
+        weights = self.fc(x)
+        return x * weights  # channel-wise multiplication
+
+class ResnetBlock(nn.Module):
+    def __init__(self, dim, reduction=16):
+        super(ResnetBlock, self).__init__()
+        self.conv_block = self.build_conv_block(dim)
+        self.se = SEBlock(dim, reduction)
+    
+    def build_conv_block(self, dim):
+        conv_block = [
+            nn.ReflectionPad2d(1),
+            nn.Conv2d(dim, dim, kernel_size=3, padding=0),
+            nn.InstanceNorm2d(dim),
+            nn.ReLU(True),
+            nn.ReflectionPad2d(1),
+            nn.Conv2d(dim, dim, kernel_size=3, padding=0),
+            nn.InstanceNorm2d(dim)
+        ]
+        return nn.Sequential(*conv_block)
+    
+    def forward(self, x):
+        out = self.conv_block(x)
+        out = self.se(out)  # apply squeeze-and-excitation
+        return x + out
+
+class GeneratorResNet(nn.Module):
+    def __init__(self, input_nc, output_nc, n_residual_blocks=9):
+        super(GeneratorResNet, self).__init__()
+
+        # Initial convolution block
+        model = [nn.ReflectionPad2d(3),
+                 nn.Conv2d(input_nc, 64, 7),
+                 nn.InstanceNorm2d(64),
+                 nn.ReLU(inplace=True)]
+
+        # Downsampling
+        in_features = 64
+        out_features = in_features * 2
+        for _ in range(2):
+            model += [nn.Conv2d(in_features, out_features, 3, stride=2, padding=1),
+                      nn.InstanceNorm2d(out_features),
+                      nn.ReLU(inplace=True)]
+            in_features = out_features
+            out_features = in_features * 2
+
+        # Residual blocks
+        for _ in range(n_residual_blocks):
+            model += [ResnetBlock(in_features)]
+
+        # Upsampling
+        out_features = in_features // 2
+        for _ in range(2):
+            model += [nn.ConvTranspose2d(in_features, out_features, 3, stride=2, padding=1, output_padding=1),
+                      nn.InstanceNorm2d(out_features),
+                      nn.ReLU(inplace=True)]
+            in_features = out_features
+            out_features = in_features // 2
+
+        # Output layer
+        model += [nn.ReflectionPad2d(3),
+                  nn.Conv2d(64, output_nc, 7),
+                  nn.Tanh()]
+
+        self.model = nn.Sequential(*model)
+
+    def forward(self, x):
+        return self.model(x)
+
+
+netG_A2B = GeneratorResNet(input_nc, output_nc)
+netG_B2A = GeneratorResNet(input_nc, output_nc)
+# Load weights for netG_A2B
+device = 'cpu'
+netG_A2B.load_state_dict(torch.load('./netG_A2B_epoch130.pth',map_location=device))
+
+# Load weights for netG_B2A
+netG_B2A.load_state_dict(torch.load('./netG_B2A_epoch130.pth',map_location=device))
+
+def generate_Y2O(uploaded_image):
+       
+    image = Image.open(uploaded_image)  # Open image using PIL
+
+    # Convert PIL image to OpenCV format (BGR)
+    open_cv_image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+    img = cv2.cvtColor(open_cv_image, cv2.COLOR_BGR2RGB)
+    img = cv2.resize(img, (128,128))
+    to_tensor = transforms.ToTensor()
+    tensor = to_tensor(img)
+    old = netG_A2B(tensor)
+    return (old.detach().permute(1, 2, 0).numpy()+1)/2
+
+
+def generate_O2Y(uploaded_image):
+       
+    image = Image.open(uploaded_image)  # Open image using PIL
+
+    # Convert PIL image to OpenCV format (BGR)
+    open_cv_image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+    img = cv2.cvtColor(open_cv_image, cv2.COLOR_BGR2RGB)
+    img = cv2.resize(img, (128,128))
+    to_tensor = transforms.ToTensor()
+    tensor = to_tensor(img)
+    young = netG_B2A(tensor)
+    return (young.detach().permute(1, 2, 0).numpy()+1)/2

netG_A2B_epoch130.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:992c0132e46cf2294651f9d5c827a9c28ddb101d9531cf232a46792da0a82eed
+size 45851722

netG_B2A_epoch130.pth

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

requirements.txt

@@ -0,0 +1,6 @@
+Pillow
+streamlit
+torch
+torchvision
+numpy
+opencv-python