resolved resizing issue

transfer.py

@@ -0,0 +1,166 @@
+from PIL import Image
+from io import BytesIO
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+import time
+
+import torch
+import torch.optim as optim
+import requests
+from torchvision import transforms, models
+
+strt = time.time()
+# get the "features" portion of VGG19
+vgg = models.vgg19(pretrained=True).features
+
+# freeze VGG params to avoid chanhe
+for param in vgg.parameters():
+    param.requires_grad_(False)
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+vgg.to(device)
+
+def load_image(img_path, max_size=400, shape=None):
+    ''' Load in and transform an image, making sure the image
+       is <= 400 pixels in the x-y dims.'''
+    if "http" in img_path:
+        response = requests.get(img_path)
+        image = Image.open(BytesIO(response.content)).convert('RGB')
+    else:
+        image = Image.open(img_path).convert('RGB')
+
+    # large images will slow down processing
+    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),
+                        transforms.ToTensor(),
+                        transforms.Normalize((0.485, 0.456, 0.406), 
+                                             (0.229, 0.224, 0.225))])
+
+    # discard the transparent, alpha channel (that's the :3) and add the batch dimension
+    image = in_transform(image)[:3,:,:].unsqueeze(0)
+    return image
+
+# load in content and style image
+content = load_image('imgs/tanya_deepak.jpg').to(device)
+# Resize style to match content, makes code easier
+style = load_image('imgs/delaunay_abstract.jpg', shape=content.shape[-2:]).to(device)
+
+def im_convert(tensor):
+    """ Display a tensor as an image. """
+
+    image = tensor.to("cpu").clone().detach()
+    image = image.numpy().squeeze()
+    image = image.transpose(1,2,0)
+    image = image * np.array((0.229, 0.224, 0.225)) + np.array((0.485, 0.456, 0.406))
+    image = image.clip(0, 1)
+
+    return image
+
+def get_features(image, model, layers=None):
+    """ Run an image forward through a model and get the features for 
+        a set of layers. Default layers are for VGGNet matching Gatys et al (2016)
+    """
+
+    ## TODO: Complete mapping layer names of PyTorch's VGGNet to names from the paper
+    ## Need the layers for the content and style representations of an image
+    if layers is None:
+        layers = {'0': 'conv1_1',
+                  '5': 'conv2_1', 
+                  '10': 'conv3_1', 
+                  '19': 'conv4_1',
+                  '21': 'conv4_2',  ## content representation
+                  '28': 'conv5_1'}
+
+    features = {}
+    x = image
+    # model._modules is a dictionary holding each module in the model
+    for name, layer in model._modules.items():
+        x = layer(x)
+        if name in layers:
+            features[layers[name]] = x
+
+    return features
+
+def gram_matrix(tensor):
+
+    # get the batch_size, depth, height, and width of the Tensor
+    _, d, h, w = tensor.size()
+
+    # reshape so we're multiplying the features for each channel
+    tensor = tensor.view(d, h * w)
+
+    # calculate the gram matrix
+    gram = torch.mm(tensor, tensor.t())
+
+    return gram
+
+# get content and style features only once before training
+content_features = get_features(content, vgg)
+style_features = get_features(style, vgg)
+
+# calculate the gram matrices for each layer of our style representation
+style_grams = {layer: gram_matrix(style_features[layer]) for layer in style_features}
+
+# create a third "target" image and prep it for change
+# it is a good idea to start of with the target as a copy of our *content* image
+# then iteratively change its style
+target = content.clone().requires_grad_(True).to(device)
+
+style_weights = {'conv1_1': 1.,
+                 'conv2_1': 0.75,
+                 'conv3_1': 0.2,
+                 'conv4_1': 0.2,
+                 'conv5_1': 0.2}
+
+content_weight = 1  # alpha
+style_weight = 1e6  # beta
+
+# iteration hyperparameters
+optimizer = optim.Adam([target], lr=0.003)
+steps = 2000  # decide how many iterations to update your image (5000)
+
+for ii in range(1, steps+1):
+
+    # get the features from your target image
+    target_features = get_features(target, vgg)
+
+    # the content loss
+    content_loss = torch.mean((target_features['conv4_2'] - content_features['conv4_2'])**2)
+
+    # the style loss
+    # initialize the style loss to 0
+    style_loss = 0
+    # then add to it for each layer's gram matrix loss
+    for layer in style_weights:
+        # get the "target" style representation for the layer
+        target_feature = target_features[layer]
+        target_gram = gram_matrix(target_feature)
+        _, d, h, w = target_feature.shape
+        # get the "style" style representation
+        style_gram = style_grams[layer]
+        # the style loss for one layer, weighted appropriately
+        layer_style_loss = style_weights[layer] * torch.mean((target_gram - style_gram)**2)
+        # add to the style loss
+        style_loss += layer_style_loss / (d * h * w)
+
+    # calculate the *total* loss
+    total_loss = content_weight * content_loss + style_weight * style_loss
+
+    # update your target image
+    optimizer.zero_grad()
+    total_loss.backward()
+    optimizer.step()
+
+final = im_convert(target)
+matplotlib.image.imsave('imgs/tanya_deepak_delaunay.jpg', final)
+
+end = time.time()