first commit

.gitattributes

@@ -32,3 +32,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+models/** filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,74 @@
+### 1. Imports and class names setup ### 
+import gradio as gr
+import os
+import torch
+import utils
+from typing import Tuple, Dict
+from model import TransformerNet
+from torchvision import transforms
+from PIL import Image
+
+# Get model
+model_dir = '/models'
+models = list(Path(model_dir).glob("*/*.pth.tar"))
+models = sorted(models)
+
+# Get style image
+style_dir = '/style-images'
+style_list = list(Path(style_dir).glob("*"))
+style_list = sorted(style_list)
+
+# Get examples
+example_list = [["examples/" + example] for example in os.listdir("examples")]
+
+def transfer(image, model):
+    device = 'cpu'
+
+    width = image.size[0]
+    height = image.size[1]
+
+    if width > 750 or height > 500:
+      iamge = image.thumbnail((712, 474))
+
+    # load model
+    style_model = TransformerNet()
+    state_dict = torch.load(models[int(model)], map_location=torch.device('cpu'))
+    style_model.load_state_dict(state_dict["state_dict"])
+
+    content_transform = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Lambda(lambda x: x.mul(255))
+    ])
+    content_image = content_transform(image)
+    content_image = content_image.unsqueeze(0).to(device)
+
+    style_model.eval()
+    with torch.no_grad():
+        style_model.to(device)
+        output = style_model(content_image).cpu()
+
+    img = utils.deprocess(output[0])
+    img = Image.fromarray(img)
+    return img, style_list[int(model)]
+
+# Create title, description and article strings
+title = "Image Style Transfer"
+description = "Choose a image that you want to transfer and the corresponding style. The app will be transfer your image. You will have received new image."
+article = "Model have created base on paper [Perceptual Losses for Real-Time Style Transfer and Super-Resolution](https://arxiv.org/pdf/1603.08155v1.pdf)."
+
+image_output_1 = gr.Image(label='Tranfer') # output result
+image_output_2 = gr.Image(label='Style Image') # Show style image
+
+# Create the Gradio demo
+demo = gr.Interface(fn=transfer, # mapping function from input to output
+                    inputs=[gr.Image(type="pil", label='Input'),
+                            gr.Dropdown(choices=[i.parent.name for i in models], value='rain_princess', type='index', label="Style", info="Chooses kind of style image")], # what are the inputs?
+                    outputs=[image_output_1, image_output_2], # our fn has two outputs, therefore we have two outputs
+                    label = ['One', "Two"],
+                    examples=example_list,
+                    title=title,
+                    description=description,
+                    article=article)
+
+# Launch the demo!
+demo.launch()

model.py

@@ -0,0 +1,78 @@
+import torch
+from torch import nn
+
+class Residual_block(nn.Module):
+  """Residual block
+  Architecture: https://arxiv.org/pdf/1610.02915.pdf
+  """
+  def __init__(self, channel):
+    super(Residual_block, self).__init__()
+    self.conv_1 = nn.Conv2d(in_channels=channel, out_channels=channel,
+                            padding='same', kernel_size=3, stride=1)
+    self.inst1 = nn.InstanceNorm2d(channel, affine=True)
+    self.conv_2 = nn.Conv2d(in_channels=channel, out_channels=channel,
+                            padding='same', kernel_size=3, stride=1)
+    self.inst2 = nn.InstanceNorm2d(channel, affine=True)
+    self.relu = nn.ReLU()
+
+  def forward(self, x):
+    residual = x
+    out = self.relu(self.inst1(self.conv_1(x)))
+    out = self.inst2(self.conv_2(out))
+    return self.relu(out + residual)
+
+class TransformerNet(nn.Module):
+  def __init__(self):
+    super(TransformerNet, self).__init__()
+    # Downsampling
+    self.conv1 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=9, stride=1, padding = 9//2)
+    self.BN_1 = nn.InstanceNorm2d(num_features=32, affine=True)
+    self.down_1 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=2, padding = 1)
+    self.BN_2 = nn.InstanceNorm2d(num_features=64, affine=True)
+    self.down_2 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=2, padding = 1)
+    self.BN_3 = nn.InstanceNorm2d(num_features=128, affine=True)
+    # Residual connect
+    self.res_1 = Residual_block(128)
+    self.res_2 = Residual_block(128)
+    self.res_3 = Residual_block(128)
+    self.res_4 = Residual_block(128)
+    self.res_5 = Residual_block(128)
+    # Upsampling
+    self.up_1 = nn.ConvTranspose2d(in_channels=128, out_channels=64, kernel_size=3, stride=2, padding=1, output_padding= 1)
+    self.BN_4 = nn.InstanceNorm2d(num_features=64, affine=True)
+    self.up_2 = nn.ConvTranspose2d(in_channels=64, out_channels=32, kernel_size=3, stride=2, padding = 1, output_padding= 1)
+    self.BN_5 = nn.InstanceNorm2d(num_features=32, affine=True)
+    self.conv2 = nn.Conv2d(in_channels=32, out_channels=3, kernel_size=9, stride=1, padding = 9//2)
+
+    self.relu = nn.ReLU()
+
+
+
+  def forward(self, x):
+    y = self.relu(self.BN_1(self.conv1(x)))
+    # print(y.shape)
+    y = self.relu(self.BN_2(self.down_1(y)))
+    # print(y.shape)
+    y = self.relu(self.BN_3(self.down_2(y)))
+    # print(y.shape)
+
+    # print()
+    y = self.res_1(y)
+    # print(y.shape)
+    y = self.res_2(y)
+    # print(y.shape)
+    y = self.res_3(y)
+    # print(y.shape)
+    y = self.res_4(y)
+    # print(y.shape)
+    y = self.res_5(y)
+    # print(y.shape)
+
+    # print()
+    y = self.relu(self.BN_4(self.up_1(y)))
+    # print(y.shape)
+    y = self.relu(self.BN_5(self.up_2(y)))
+    # print(y.shape)
+    y = self.conv2(y)
+    # print(y.shape)
+    return y

models/candy/candy_Epoch_3_Batch idx_4999.pth.tar

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

models/mosaic/mosaic_Epoch_6_Batch idx_3999.pth.tar

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

models/rain_princess/rain_princess.pth.tar

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

models/vg_la_coffe/vg_la_cafe_Epoch_6_Batch idx_3999.pth.tar

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

models/wave_crop/wave_crop_Epoch_4_Batch idx_2999.pth.tar

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

models/weeping_woman/woman_Epoch_9_Batch idx_3999.pth.tar

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

requirements.txt

@@ -0,0 +1,3 @@
+torch==1.12.0
+torchvision==0.13.0
+gradio==3.1.4

utils.py

@@ -0,0 +1,54 @@
+import torch
+from PIL import Image
+import numpy as np
+
+
+mean = [0.4763, 0.4507, 0.4094]
+std = [0.2702, 0.2652, 0.2811]
+
+def load_image(filename, size=None):
+    img = Image.open(filename).convert('RGB')
+    if size is not None:
+        img = img.resize((size, size), Image.ANTIALIAS)
+    return img
+
+
+class UnNormalize(object):
+    def __init__(self, mean, std):
+        self.mean = mean
+        self.std = std
+
+    def __call__(self, tensor):
+        """
+        Args:
+            tensor (Tensor): Tensor image of size (C, H, W) to be normalized.
+        Returns:
+            Tensor: Normalized image.
+        """
+        for t, m, s in zip(tensor, self.mean, self.std):
+            t.mul_(s).add_(m)
+            # The normalize code -> t.sub_(m).div_(s)
+        return tensor
+
+def deprocess(image_tensor):
+    """ Denormalizes and rescales image tensor """
+    unnorm = UnNormalize(mean=mean, std=std)
+    img = image_tensor
+    unnorm(img)
+    img *= 255
+    image_np = torch.clamp(img, 0, 255).numpy().astype(np.uint8)
+    image_np = image_np.transpose(1, 2, 0)
+    return image_np
+
+def save_image(filename, data):
+    img = deprocess(data)
+    img = Image.fromarray(img)
+    img.save(filename)
+
+
+def gram_matrix(y):
+    (b, ch, h, w) = y.size()
+    features = y.view(b, ch, w * h)
+    features_t = features.transpose(1, 2)
+    gram = features.bmm(features_t) / (ch * h * w)
+    return gram

vgg.py

@@ -0,0 +1,38 @@
+import torch.nn as nn
+from collections import namedtuple
+from torchvision.models import vgg16, VGG16_Weights
+
+class VGG16(nn.Module):
+    def __init__(self, requires_grad=False):
+        super(VGG16, self).__init__()
+
+        weights = VGG16_Weights.DEFAULT
+        vgg_pretrained_features = vgg16(weights=weights).features
+        self.slice1 = nn.Sequential()
+        self.slice2 = nn.Sequential()
+        self.slice3 = nn.Sequential()
+        self.slice4 = nn.Sequential()
+        for x in range(4):
+            self.slice1.add_module(str(x), vgg_pretrained_features[x])
+        for x in range(4, 9):
+            self.slice2.add_module(str(x), vgg_pretrained_features[x])
+        for x in range(9, 16):
+            self.slice3.add_module(str(x), vgg_pretrained_features[x])
+        for x in range(16, 23):
+            self.slice4.add_module(str(x), vgg_pretrained_features[x])
+        if not requires_grad:
+            for param in self.parameters():
+                param.requires_grad = False
+
+    def forward(self, X):
+        h = self.slice1(X)
+        h_relu1_2 = h
+        h = self.slice2(h)
+        h_relu2_2 = h
+        h = self.slice3(h)
+        h_relu3_3 = h
+        h = self.slice4(h)
+        h_relu4_3 = h
+        vgg_outputs = namedtuple("VggOutputs", ['relu1_2', 'relu2_2', 'relu3_3', 'relu4_3'])
+        out = vgg_outputs(h_relu1_2, h_relu2_2, h_relu3_3, h_relu4_3)
+        return out