first commit

.gitattributes

@@ -33,3 +33,5 @@ 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
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.13" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.13 (style_transfer_app)" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/style_transfer_app.iml" filepath="$PROJECT_DIR$/.idea/style_transfer_app.iml" />
+    </modules>
+  </component>
+</project>

.idea/style_transfer_app.iml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.venv" />
+    </content>
+    <orderEntry type="jdk" jdkName="Python 3.13 (style_transfer_app)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

app.py

@@ -0,0 +1,62 @@
+import gradio as gr
+import torch
+
+from model import generate_image
+from utils import load_model, load_image, im_convert, device
+
+
+vgg = load_model(d=device)
+
+max_image_size = 400
+
+
+def generate(content: torch.Tensor, style: torch.Tensor, alpha_slider: float):
+
+    content_img = load_image(image=content, max_size=max_image_size).to(device)
+    style_img = load_image(image=style, max_size=max_image_size, shape=content_img.shape[-2:]).to(device)
+
+    target_img = content_img.clone().requires_grad_(True).to(
+        device)  # Initialize the target image as a clone of the original content image
+    target = generate_image(model=vgg, content=content_img, style=style_img, target=target_img, steps = 2700, content_wt=alpha_slider)
+    return im_convert(target)
+
+
+def check_inputs(img1, img2):
+    """Enable the submit button only if both images are uploaded."""
+    if img1 is not None and img2 is not None:
+        return gr.update(interactive=True)  # Enable button
+    return gr.update(interactive=False)  # Keep button disabled
+
+with gr.Blocks() as demo:
+    gr.Markdown("Transfer Image Style with the VGG19 model.")
+
+    with gr.Row():
+        content_image = gr.Image(type="pil", label="Original Image")
+        style_image = gr.Image(type="pil", label="Style Reference Image")
+
+    # Examples Section
+    gr.Examples(
+            examples=[
+                ["./images/input-image-1.jpg", "./images/style-image-1.jpg"],
+                ["./images/input-image-2.jpg", "./images/style-image-2.jpg"]
+            ],
+            inputs=[content_image, style_image]
+    )
+
+    alpha_slider = gr.Slider(0, 1, value=1, step=0.1, label="Blending Ratio")
+    submit_button = gr.Button("Blend Images", "Generate", variant="primary", interactive=False)
+
+    output = gr.Image(label="Blended Image")
+
+    submit_button.click(generate, inputs=[content_image, style_image, alpha_slider], outputs=output)
+
+    # When images change, check if both are uploaded to enable the button
+    content_image.change(fn=check_inputs, inputs=[content_image, style_image], outputs=submit_button)
+    style_image.change(fn=check_inputs, inputs=[content_image, style_image], outputs=submit_button)
+
+
+# Launch the demo!
+demo.launch()
+
+# if __name__ == "__main__":
+#     demo.launch()

model.py

@@ -0,0 +1,52 @@
+import torch
+import torch.optim as optim
+from torch import nn
+from utils import get_features, gram_matrix
+
+
+# weight early layers more heavily
+style_weights = {'conv1_1': 1.,
+                 'conv2_1': 0.75,
+                 'conv3_1': 0.2,
+                 'conv4_1': 0.2,
+                 'conv5_1': 0.2}
+
+# the balance between style and content
+content_weight = 1  # alpha
+style_weight = 1e9  # beta
+
+
+
+def generate_image(model: nn.Module, content: torch.Tensor, style: torch.Tensor, target: torch.Tensor, steps = 2700, content_wt=content_weight):
+    content_features = get_features(content, model)
+    style_features = get_features(style, model)
+
+    # apply gram_matrix to each of the style features for that same layer
+    style_grams = {layer: gram_matrix(style_features[layer]) for layer in style_features}
+
+    optimizer = optim.Adam([target], lr=0.003)
+
+    for ii in range(1, steps + 1):
+        target_features = get_features(target, model)
+        content_loss = torch.mean((target_features['conv4_2'] - content_features['conv4_2']) ** 2)
+        style_loss = 0
+
+        # calculate the style loss
+        for layer in style_weights:
+            target_feature = target_features[layer]
+            target_gram = gram_matrix(target_feature)
+            style_gram = style_grams[layer]
+            layer_style_loss = style_weights[layer] * torch.mean((target_gram - style_gram) ** 2)
+            _, d, h, w = target_feature.shape
+            style_loss += layer_style_loss / (d * h * w)
+
+        total_loss = content_wt * content_loss + style_weight * style_loss
+
+        optimizer.zero_grad()
+        total_loss.backward()
+        optimizer.step()
+
+    return target
+
+
+

requirements.txt

@@ -0,0 +1,4 @@
+gradio
+transformers
+torch
+torchvision

utils.py

@@ -0,0 +1,81 @@
+import torch
+import torch.optim as optim
+from torchvision import transforms, models
+from PIL import Image
+import numpy as np
+
+device = torch.device("cuda" if torch.cuda.is_available() else "mps" if torch.mps.is_available() else "cpu")
+
+
+
+def load_model(d=device):
+    weights = models.VGG19_Weights.DEFAULT
+    vgg = models.vgg19(weights=weights).features  # only uses the feature layers of the model
+
+    # https://pytorch.org/docs/stable/generated/torch.Tensor.requires_grad_.html
+    for param in vgg.parameters():
+        param.requires_grad_(False)
+
+    vgg.to(device=d)
+    return vgg
+
+
+# max_size limits the image size to 400 pixel
+def load_image(image, max_size=400, shape=None):
+    # image = Image.open(img_path).convert('RGB')
+
+    # either the horizontal or vertical image size exceeds max_size, set the size to max_size
+    if max(image.size) > max_size:
+        size = max_size
+    else:
+        size = max(image.size)
+
+    if shape is not None:
+        size = shape
+
+    in_transform = transforms.Compose([
+        transforms.Resize(size),  # Resize will scale the smaller edge of the image to 'size'
+        transforms.ToTensor(),
+        transforms.Normalize((0.5, 0.5, 0.5),
+                             (0.5, 0.5, 0.5))])
+
+    image = in_transform(image).unsqueeze(0)
+
+    return image
+
+
+def im_convert(tensor):
+    image = tensor.to("cpu").clone().detach()
+    image = image.numpy().squeeze()
+    image = image.transpose(1,2,0)
+    image = image * np.array((0.5, 0.5, 0.5)) + np.array((0.5, 0.5, 0.5))
+    image = image.clip(0, 1)
+
+    return image
+
+
+def get_features(image, model):
+    layers = {'0': 'conv1_1',  # Style Extraction
+              '5': 'conv2_1',  # Style Extraction
+              '10': 'conv3_1',  # Style Extraction
+              '19': 'conv4_1',  # Style Extraction
+              '21': 'conv4_2',  # Content Extraction
+              '28': 'conv5_1'}  # Style Extraction
+
+    features = {}
+
+    for name, layer in model._modules.items():
+        # feed the image through the network
+        image = layer(image)  # run the image through this layer and store it as the output for the layer
+        if name in layers:
+            features[layers[name]] = image
+
+    return features
+
+
+# Eliminate content feature and only maintain style features
+def gram_matrix(tensor):
+    _, d, h, w = tensor.size()  # d is depth, h is height, w is width
+    tensor = tensor.view(d, h * w)  # reshape the data into a 2 dimensional tensor
+    gram = torch.mm(tensor, tensor.t())
+    return gram