upload deep dream

Author: L1aoXingyu

chapter8_Application/Deep-Dream/README.md

@@ -0,0 +1,2 @@
+# Deep-Dream
+PyTorch implement of Google Deep Dream

chapter8_Application/Deep-Dream/deepdream.py

@@ -0,0 +1,73 @@
+import numpy as np
+import torch
+from util import showtensor
+import scipy.ndimage as nd
+from torch.autograd import Variable
+
+
+def objective_L2(dst, guide_features):
+    return dst.data
+
+
+def make_step(img, model, control=None, distance=objective_L2):
+    mean = np.array([0.485, 0.456, 0.406]).reshape([3, 1, 1])
+    std = np.array([0.229, 0.224, 0.225]).reshape([3, 1, 1])
+
+    learning_rate = 2e-2
+    max_jitter = 32
+    num_iterations = 20
+    show_every = 10
+    end_layer = 3
+    guide_features = control
+
+    for i in range(num_iterations):
+        shift_x, shift_y = np.random.randint(-max_jitter, max_jitter + 1, 2)
+        img = np.roll(np.roll(img, shift_x, -1), shift_y, -2)
+        # apply jitter shift
+        model.zero_grad()
+        img_tensor = torch.Tensor(img)
+        if torch.cuda.is_available():
+            img_variable = Variable(img_tensor.cuda(), requires_grad=True)
+        else:
+            img_variable = Variable(img_tensor, requires_grad=True)
+
+        act_value = model.forward(img_variable, end_layer)
+        diff_out = distance(act_value, guide_features)
+        act_value.backward(diff_out)
+        ratio = np.abs(img_variable.grad.data.cpu().numpy()).mean()
+        learning_rate_use = learning_rate / ratio
+        img_variable.data.add_(img_variable.grad.data * learning_rate_use)
+        img = img_variable.data.cpu().numpy()  # b, c, h, w
+        img = np.roll(np.roll(img, -shift_x, -1), -shift_y, -2)
+        img[0, :, :, :] = np.clip(img[0, :, :, :], -mean / std,
+                                  (1 - mean) / std)
+        if i == 0 or (i + 1) % show_every == 0:
+            showtensor(img)
+    return img
+
+
+def dream(model,
+          base_img,
+          octave_n=6,
+          octave_scale=1.4,
+          control=None,
+          distance=objective_L2):
+    octaves = [base_img]
+    for i in range(octave_n - 1):
+        octaves.append(
+            nd.zoom(
+                octaves[-1], (1, 1, 1.0 / octave_scale, 1.0 / octave_scale),
+                order=1))
+
+    detail = np.zeros_like(octaves[-1])
+    for octave, octave_base in enumerate(octaves[::-1]):
+        h, w = octave_base.shape[-2:]
+        if octave > 0:
+            h1, w1 = detail.shape[-2:]
+            detail = nd.zoom(
+                detail, (1, 1, 1.0 * h / h1, 1.0 * w / w1), order=1)
+
+        input_oct = octave_base + detail
+        print(input_oct.shape)
+        out = make_step(input_oct, model, control, distance=distance)
+        detail = out - octave_base

chapter8_Application/Deep-Dream/guide_image/flower.jpg

@@ -0,0 +1,77 @@
+__author__ = 'SherlockLiao'
+
+import torch
+from torch import nn
+from torchvision import models
+import torch.utils.model_zoo as model_zoo
+
+
+model_urls = {
+    'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
+    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
+    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
+    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
+    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
+}
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(Bottleneck, self).__init__()
+        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
+                               padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
+        self.bn3 = nn.BatchNorm2d(planes * 4)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class CustomResNet(models.resnet.ResNet):
+    def forward(self, x, end_layer):
+        """
+        end_layer range from 1 to 4
+        """
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+
+        layers = [self.layer1, self.layer2, self.layer3, self.layer4]
+        for i in range(end_layer):
+            x = layers[i](x)
+        return x
+
+
+def resnet50(pretrained=False, **kwargs):
+    model = CustomResNet(Bottleneck, [3, 4, 6, 3], **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['resnet50']))
+    return model

chapter8_Application/Deep-Dream/guide_image/input.png

@@ -0,0 +1,22 @@
+import PIL.Image
+from io import BytesIO
+from IPython.display import clear_output, Image, display
+import numpy as np
+
+
+def showarray(a, fmt='jpeg'):
+    a = np.uint8(np.clip(a, 0, 255))
+    f = BytesIO()
+    PIL.Image.fromarray(a).save(f, fmt)
+    display(Image(data=f.getvalue()))
+
+
+def showtensor(a):
+    mean = np.array([0.485, 0.456, 0.406]).reshape([1, 1, 3])
+    std = np.array([0.229, 0.224, 0.225]).reshape([1, 1, 3])
+    inp = a[0, :, :, :]
+    inp = inp.transpose(1, 2, 0)
+    inp = std * inp + mean
+    inp *= 255
+    showarray(inp)
+    clear_output(wait=True)