upload

Author: L1aoXingyu

chapter6_Gan/autoencoder/Variational_autoencoder.py renamed to chapter6_GAN/autoencoder/Variational_autoencoder.py

@@ -0,0 +1,2 @@
+# neural-transfer
+This is my implement of neural-transfer according to http://pytorch.org/tutorials/advanced/neural_style_tutorial.html#sphx-glr-advanced-neural-style-tutorial-py

chapter6_Gan/autoencoder/conv_autoencoder.py renamed to chapter6_GAN/autoencoder/conv_autoencoder.py

@@ -0,0 +1,57 @@
+import torch.nn as nn
+import torchvision.models as models
+
+import loss
+
+vgg = models.vgg19(pretrained=True).features
+vgg = vgg.cuda()
+
+content_layers_default = ['conv_4']
+style_layers_default = ['conv_1', 'conv_2', 'conv_3', 'conv_4', 'conv_5']
+
+
+def get_style_model_and_loss(style_img,
+                             content_img,
+                             cnn=vgg,
+                             style_weight=1000,
+                             content_weight=1,
+                             content_layers=content_layers_default,
+                             style_layers=style_layers_default):
+
+    content_loss_list = []
+    style_loss_list = []
+
+    model = nn.Sequential()
+    model = model.cuda()
+    gram = loss.Gram()
+    gram = gram.cuda()
+
+    i = 1
+    for layer in cnn:
+        if isinstance(layer, nn.Conv2d):
+            name = 'conv_' + str(i)
+            model.add_module(name, layer)
+
+            if name in content_layers_default:
+                target = model(content_img)
+                content_loss = loss.Content_Loss(target, content_weight)
+                model.add_module('content_loss_' + str(i), content_loss)
+                content_loss_list.append(content_loss)
+
+            if name in style_layers_default:
+                target = model(style_img)
+                target = gram(target)
+                style_loss = loss.Style_Loss(target, style_weight)
+                model.add_module('style_loss_' + str(i), style_loss)
+                style_loss_list.append(style_loss)
+
+            i += 1
+        if isinstance(layer, nn.MaxPool2d):
+            name = 'pool_' + str(i)
+            model.add_module(name, layer)
+
+        if isinstance(layer, nn.ReLU):
+            name = 'relu' + str(i)
+            model.add_module(name, layer)
+
+    return model, style_loss_list, content_loss_list

chapter6_Gan/autoencoder/simple_autoencoder.py renamed to chapter6_GAN/autoencoder/simple_autoencoder.py

@@ -0,0 +1,18 @@
+import PIL.Image as Image
+import torchvision.transforms as transforms
+
+img_size = 512
+
+
+def load_img(img_path):
+    img = Image.open(img_path).convert('RGB')
+    img = img.resize((img_size, img_size))
+    img = transforms.ToTensor()(img)
+    img = img.unsqueeze(0)
+    return img
+
+
+def show_img(img):
+    img = img.squeeze(0)
+    img = transforms.ToPILImage()(img)
+    img.show()

chapter6_Gan/gan/conv_gan.py renamed to chapter6_GAN/gan/conv_gan.py

@@ -0,0 +1,51 @@
+import torch.nn as nn
+import torch
+
+
+class Content_Loss(nn.Module):
+    def __init__(self, target, weight):
+        super(Content_Loss, self).__init__()
+        self.weight = weight
+        self.target = target.detach() * self.weight
+        # 必须要用detach来分离出target，这时候target不再是一个Variable，这是为了动态计算梯度，否则forward会出错，不能向前传播
+        self.criterion = nn.MSELoss()
+
+    def forward(self, input):
+        self.loss = self.criterion(input * self.weight, self.target)
+        out = input.clone()
+        return out
+
+    def backward(self, retain_variabels=True):
+        self.loss.backward(retain_variables=retain_variabels)
+        return self.loss
+
+
+class Gram(nn.Module):
+    def __init__(self):
+        super(Gram, self).__init__()
+
+    def forward(self, input):
+        a, b, c, d = input.size()
+        feature = input.view(a * b, c * d)
+        gram = torch.mm(feature, feature.t())
+        gram /= (a * b * c * d)
+        return gram
+
+
+class Style_Loss(nn.Module):
+    def __init__(self, target, weight):
+        super(Style_Loss, self).__init__()
+        self.weight = weight
+        self.target = target.detach() * self.weight
+        self.gram = Gram()
+        self.criterion = nn.MSELoss()
+
+    def forward(self, input):
+        G = self.gram(input) * self.weight
+        self.loss = self.criterion(G, self.target)
+        out = input.clone()
+        return out
+
+    def backward(self, retain_variabels=True):
+        self.loss.backward(retain_variables=retain_variabels)
+        return self.loss