Add applications files and generator saved models.

G_XtoY.pth

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

G_YtoX.pth

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

app.py

@@ -0,0 +1,49 @@
+import gradio as gr
+import torch
+from torchvision import transforms
+from archs import CycleGenerator
+import warnings
+
+warnings.filterwarnings("ignore")
+
+# instantiate generators
+G_XtoY = CycleGenerator(conv_dim=64) # Apple -> Windows
+G_YtoX = CycleGenerator(conv_dim=64) # Windows -> Apple
+
+# load weights (on CPU because Huggingface does not provide free GPU computing)
+device = torch.device('cpu')
+G_XtoY.load_state_dict(torch.load('G_XtoY.pth', map_location=device)); G_XtoY.eval()
+G_YtoX.load_state_dict(torch.load('G_YtoX.pth', map_location=device)); G_YtoX.eval()
+
+def generate(input_image, radio):
+    transform = transforms.Compose([
+                    transforms.Resize(32),
+                    transforms.ToTensor(),
+                    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
+                ])
+    input_image = transform(input_image).unsqueeze(0)
+    with torch.no_grad():
+        if radio == 'Apple to Windows':
+            out = G_XtoY(input_image).squeeze().numpy()
+        else:
+            out = G_YtoX(input_image).squeeze().numpy()
+    return out.transpose(1, 2, 0)
+
+
+input_image = gr.inputs.Image(source="upload", type="pil", label="Input Image")
+radio = gr.inputs.Radio(
+    choices=['Apple to Windows', 'Windows to Apple'],
+    label="Choose Conversion"
+)
+
+output_image = gr.outputs.Image(type="numpy", label="Converted Image")
+
+iface = gr.Interface(
+    generate,
+    [input_image, radio],
+    output_image,
+    title = "Apple/Windows Style Emoji Conversion Using Cycle-GAN",
+    article = "By: Arian Tashakkor"
+)
+
+iface.launch()

archs.py

@@ -0,0 +1,32 @@
+from layers import *
+from torch.nn import functional as F
+
+class CycleGenerator(nn.Module):
+    def __init__(self, conv_dim=64):
+        super(CycleGenerator, self).__init__()
+        
+        self.conv1 = conv(3, conv_dim, 4)
+        self.conv2 = conv(conv_dim, conv_dim * 2, 4)
+        # experiment with number of residual_blocks
+        self.res_block1 = ResidualBlock(conv_dim * 2)
+        self.res_block2 = ResidualBlock(conv_dim * 2)
+        self.deconv1 = deconv(conv_dim * 2, conv_dim, 4)
+        self.deconv2 = deconv(conv_dim, 3, 4, norm=False)
+    
+    def forward(self, x):
+        """Generates an image conditioned on an input image.
+            Input
+            -----
+                x: BS x 3 x 32 x 32
+            Output
+            ------
+                out: BS x 3 x 32 x 32
+        """
+        out = F.relu(self.conv1(x))
+        out = F.relu(self.conv2(out))
+        out = F.relu(self.res_block1(out))
+        out = F.relu(self.res_block2(out))
+        out = F.relu(self.deconv1(out))
+        out = F.tanh(self.deconv2(out))
+        
+        return out

layers.py

@@ -0,0 +1,49 @@
+from torch import nn
+## LAYER UTILITIES ####################################################################
+def deconv(in_channels, out_channels, kernel_size, stride=2, padding=1, norm=True, norm_mode='batch'):
+    """Creates a transposed-convolutional layer, with optional batch/instance normalization.
+    """
+    layers = []
+    layers.append(
+        nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride, padding, bias=False)
+    )
+    if norm:
+        if norm_mode == 'instance':
+            layers.append(
+                nn.InstanceNorm2d(out_channels)
+            )
+        elif norm_mode == 'batch':
+            layers.append(
+                nn.BatchNorm2d(out_channels)
+            )
+    return nn.Sequential(*layers)
+
+def conv(in_channels, out_channels, kernel_size, stride=2, padding=1, norm=True, norm_mode='batch'):
+    """Creates a convolutional layer, with optional batch/instance normalization.
+    """
+    layers = []
+    layers.append(
+        nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, bias=False)
+    )
+    if norm:
+        if norm_mode == 'instance':
+            layers.append(
+                nn.InstanceNorm2d(out_channels)
+            )
+        elif norm_mode == 'batch':
+            layers.append(
+                nn.BatchNorm2d(out_channels)
+            )
+    return nn.Sequential(*layers)
+
+class ResidualBlock(nn.Module):
+    """Instatiates a residual block with kernel_size = 3
+    """
+    def __init__(self, conv_dim):
+        super(ResidualBlock, self).__init__()
+        self._conv = conv(
+            conv_dim, conv_dim, kernel_size=3, stride=1, padding=1
+        )
+    
+    def forward(self, x):
+        return x + self._conv(x)