Style Transfer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Style Transfer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.preprocessing.image import load_img, img_to_array\n",
    "from keras.applications import vgg16, vgg19\n",
    "from keras import backend as K\n",
    "import numpy as np\n",
    "import time\n",
    "import glob\n",
    "import imageio\n",
    "from scipy.optimize import fmin_l_bfgs_b\n",
    "from itertools import combinations\n",
    "\n",
    "from scipy.misc import imread, imresize, imsave, fromimage, toimage\n",
    "\n",
    "try:\n",
    "    from io import BytesIO\n",
    "except ImportError:\n",
    "    from StringIO import StringIO as BytesIO\n",
    "import PIL\n",
    "from IPython.display import clear_output, Image, display, HTML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_image_path = 'style_transfer/florence2.jpg'\n",
    "style1_image_path = 'style_transfer/manierismus.jpg'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def showarray(a, fmt='jpeg'):\n",
    "    f = BytesIO()\n",
    "    PIL.Image.fromarray(a).save(f, fmt)\n",
    "    display(Image(data=f.getvalue()))\n",
    "\n",
    "def preprocess_image(image_path, target_size=None):\n",
    "    img = load_img(image_path, target_size=target_size)\n",
    "    img = img_to_array(img)\n",
    "    img = np.expand_dims(img, axis=0)\n",
    "    img = vgg16.preprocess_input(img)\n",
    "    return img\n",
    "\n",
    "def deprocess_image(x, w, h):\n",
    "    if K.image_data_format() == 'channels_first':\n",
    "        x = x.reshape((3, w, h))\n",
    "        x = x.transpose((1, 2, 0))\n",
    "    else:\n",
    "        x = x.reshape((w, h, 3))\n",
    "    # Remove zero-center by mean pixel\n",
    "    x[:, :, 0] += 103.939\n",
    "    x[:, :, 1] += 116.779\n",
    "    x[:, :, 2] += 123.68\n",
    "    # 'BGR'->'RGB'\n",
    "    x = x[:, :, ::-1]\n",
    "    x = np.clip(x, 0, 255).astype('uint8')\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Evaluator(object):\n",
    "    def __init__(self, loss_total, result_image, **other):\n",
    "        grads = K.gradients(loss_total, result_image)\n",
    "        outputs = [loss_total] + list(other.values()) + grads\n",
    "        self.iterate = K.function([result_image], outputs)\n",
    "        self.other = list(other.keys())\n",
    "        self.other_values = {}\n",
    "        self.shape = result_image.shape\n",
    "\n",
    "        self.loss_value = None\n",
    "        self.grads_values = None\n",
    "\n",
    "    def loss(self, x):\n",
    "        outs = self.iterate([x.reshape(self.shape)])\n",
    "        self.loss_value = outs[0]\n",
    "        self.grad_values = outs[-1].flatten().astype('float64')\n",
    "        self.other_values = dict(zip(self.other, outs[1:-1]))\n",
    "        return self.loss_value\n",
    "\n",
    "    def grads(self, x):\n",
    "        return np.copy(self.grad_values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gram_matrix(x):\n",
    "    if K.image_data_format() != 'channels_first':\n",
    "        x = K.permute_dimensions(x, (2, 0, 1))\n",
    "    features = K.batch_flatten(x)\n",
    "    return K.dot(features - 1, K.transpose(features - 1)) - 1\n",
    "\n",
    "def style_loss(layer_1, layer_2):\n",
    "    gr1 = gram_matrix(layer_1)\n",
    "    gr2 = gram_matrix(layer_2)\n",
    "    return K.sum(K.square(gr1 - gr2)) / (np.prod(layer_2.shape).value ** 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run(evaluator, image, num_iter=25):\n",
    "    for i in range(num_iter):\n",
    "        start_time = time.time()\n",
    "\n",
    "        image, min_val, info = fmin_l_bfgs_b(evaluator.loss, image.flatten(), fprime=evaluator.grads, maxfun=20)\n",
    "\n",
    "        end_time = time.time()\n",
    "        clear_output()\n",
    "        showarray(deprocess_image(image.copy(), h, w))\n",
    "\n",
    "        print(\"Iteration %d completed in %ds\" % (i + 1, end_time - start_time))\n",
    "        print(\"Current loss value:\", min_val)\n",
    "        print(' '.join(k + ':' + str(evaluator.other_values[k]) for k in evaluator.other))\n",
    "    return image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def total_variation_loss(x, exp=1.25):\n",
    "    _, d1, d2, d3 = x.shape\n",
    "    if K.image_data_format() == 'channels_first':\n",
    "        a = K.square(x[:, :, :d2 - 1, :d3 - 1] - x[:, :, 1:, :d3 - 1])\n",
    "        b = K.square(x[:, :, :d2 - 1, :d3 - 1] - x[:, :, :d2 - 1, 1:])\n",
    "    else:\n",
    "        a = K.square(x[:, :d1 - 1, :d2 - 1, :] - x[:, 1:, :d2 - 1, :])\n",
    "        b = K.square(x[:, :d1 - 1, :d2 - 1, :] - x[:, :d1 - 1, 1:, :])\n",
    "    return K.sum(K.pow(a + b, exp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def content_loss(base, combination):\n",
    "    return K.sum(K.square(combination - base))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TensorShape([Dimension(3), Dimension(360), Dimension(340), Dimension(3)])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w, h = load_img(base_image_path).size\n",
    "base_image = K.variable(preprocess_image(base_image_path))\n",
    "style_image = K.variable(preprocess_image(style1_image_path, target_size=(h, w)))\n",
    "combination_image = K.placeholder(style_image.shape)\n",
    "input_tensor = K.concatenate([base_image,\n",
    "                              style_image,\n",
    "                              combination_image], axis=0)\n",
    "input_tensor.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model loaded.\n"
     ]
    }
   ],
   "source": [
    "model = vgg16.VGG16(input_tensor=input_tensor,\n",
    "                    weights='imagenet', include_top=False)\n",
    "print('Model loaded.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_outputs = [layer.output for layer in model.layers if '_conv' in layer.name]\n",
    "\n",
    "loss_content = content_loss(feature_outputs[-1][0, :, :, :],\n",
    "                            feature_outputs[-1][2, :, :, :])\n",
    "loss_variation = total_variation_loss(combination_image)\n",
    "loss_style = K.variable(0.)\n",
    "for idx, layer_features in enumerate(feature_outputs):\n",
    "    loss_style += style_loss(layer_features[1, :, :, :], layer_features[2, :, :, :]) * (0.5 ** idx)\n",
    "\n",
    "loss_content /= 40\n",
    "loss_variation /= 10000\n",
    "\n",
    "loss_total = loss_content + loss_variation + loss_style"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 100 completed in 14s\n",
      "Current loss value: 206292.53\n",
      "loss_content:44693.215 loss_variation:34538.367 loss_style:127060.945\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([  34.65453504,   31.50655543,   62.19283259, ..., -157.40903812,\n",
       "       -183.94838384, -178.13317523])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "combined_evaluator = Evaluator(loss_total, combination_image, loss_content=loss_content, \n",
    "                               loss_variation=loss_variation, loss_style=loss_style)\n",
    "run(combined_evaluator, preprocess_image(base_image_path), num_iter=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "TensorFlow-GPU",
   "language": "python",
   "name": "tf-gpu"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}