_notebooks/2021-07-20-neural-style-transfer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "35abe7f9-09b0-4b91-8378-3a63dd1b66da",
   "metadata": {
    "id": "35abe7f9-09b0-4b91-8378-3a63dd1b66da"
   },
   "source": [
    "# Neural style transfer\n",
    "\n",
    "- description: \"Neural style transfer with PyTorch\"\n",
    "- toc: false\n",
    "- branch: master\n",
    "- badges: true\n",
    "- comments: true\n",
    "- categories: [deep-learning, PyTorch, computer-vision, from scratch]\n",
    "- image: images/Covers/2021_07_20.png\n",
    "- hide: false\n",
    "- search_exclude: true\n",
    "- metadata_key1: metadata_value1\n",
    "- metadata_key2: metadata_value2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6537dbc1-ad60-4efd-b80f-95376fdc11a2",
   "metadata": {
    "id": "6537dbc1-ad60-4efd-b80f-95376fdc11a2"
   },
   "source": [
    "# Neural style transfer\n",
    "\n",
    "Neural style transfer is the application of deep learning to the task of texture transfer. The goal is to transfer some characteristics of a *style image* (e.g. a painting) onto a *content image*. The technique can be used for artistic purpose or to enhance the *content image* with missing information, e.g. in super-resolution applications. \n",
    "\n",
    "**NOTE: here insert an illustration**\n",
    "\n",
    "\n",
    "Here, I will mostly follow the original implementation by [Gatys et al. (2016)](https://www.cv-foundation.org/openaccess/content_cvpr_2016/papers/Gatys_Image_Style_Transfer_CVPR_2016_paper.pdf), and complement it with several \n",
    "improvements suggested in the literature. In Gatys et al.'s algorithm the *content* and *style* images are passed through a pretrained convolutional neural network (e.g. VGG19). The feature maps that result from the various convolution operations contain increasingly abstract representations of the original images. Thus, working with feature maps rather the the original image offers a more flexible way of combining them. From these feature maps, the algorithm performs three steps:\n",
    "\n",
    "1. feature inversion (see my previous [blogpost](https://abauville.github.io/blog/deep-learning/pytorch/computer-vision/from%20scratch/2021/07/16/feature-inversion.html))\n",
    "2. style extraction\n",
    "3. merging the *content image* with the style of the *style image*.\n",
    "\n",
    "According to Wikipedia:  \"In the visual arts, style is a \"...distinctive manner which permits the grouping of works into related categories\"[1] or \"...any distinctive, and therefore recognizable, way in which an act is performed or an artifact made or ought to be performed and made\".[2]\" For the purpose of style transfer, however, we need to define the style of a single image. A way to describe is the ensemble of characteristic visual elements (colors, lines, shapes, ...) and their relation to each other. Mathematically, this definition of style is capture using a [Gram matrix](https://en.wikipedia.org/wiki/Gram_matrix) which is, essentially, a correlation matrix of the feature maps for a given layer.\n",
    "\n",
    "The overall code architecture is identical to the [feature inversion algorithm](https://abauville.github.io/blog/deep-learning/pytorch/computer-vision/from%20scratch/2021/07/16/feature-inversion.html), with added functionality for computing gram matrices, and to compute losses with respect to both the content image and the style image.\n",
    "\n",
    "References: \n",
    "- [1] Fernie, Eric. Art History and its Methods: A critical anthology. London: Phaidon, 1995, p. 361. ISBN 978-0-7148-2991-3\n",
    "- [2] Gombrich, 150"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d23acfa4-e8dc-4aa7-af33-cbb593f19753",
   "metadata": {
    "id": "d23acfa4-e8dc-4aa7-af33-cbb593f19753"
   },
   "source": [
    "# Setup\n",
    "\n",
    "We start by importing the necessary libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "878aa2c5-0e9b-4949-b5a8-ba7c91cbcb3e",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 22565,
     "status": "ok",
     "timestamp": 1626761852353,
     "user": {
      "displayName": "Arthur Bauville",
      "photoUrl": "",
      "userId": "13412020910432312638"
     },
     "user_tz": -540
    },
    "id": "878aa2c5-0e9b-4949-b5a8-ba7c91cbcb3e",
    "outputId": "d66907dc-5e37-45bc-ee58-70f52cafbc37"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mounted at /content/drive\n"
     ]
    }
   ],
   "source": [
    "# Imports\n",
    "import torch\n",
    "import torchvision\n",
    "from torch import nn\n",
    "import skimage\n",
    "from skimage import transform\n",
    "from skimage import io\n",
    "# from im_func import show_image, timer\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import display, clear_output\n",
    "import torch.nn.functional as F\n",
    "import torchvision.transforms.functional as TF\n",
    "\n",
    "use_drive = True\n",
    "if use_drive:\n",
    "    from google.colab import drive\n",
    "    drive.mount('/content/drive')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "AIriGZFSwulg",
   "metadata": {
    "id": "AIriGZFSwulg"
   },
   "source": [
    "# Image class\n",
    "\n",
    "The image class handles, pre/post-processing and image augmentation (jittering, rotation)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e4c22e8f-37a3-4f52-9f8e-e0701e6863c2",
   "metadata": {
    "executionInfo": {
     "elapsed": 5,
     "status": "ok",
     "timestamp": 1626761852354,
     "user": {
      "displayName": "Arthur Bauville",
      "photoUrl": "",
      "userId": "13412020910432312638"
     },
     "user_tz": -540
    },
    "id": "e4c22e8f-37a3-4f52-9f8e-e0701e6863c2"
   },
   "outputs": [],
   "source": [
    "rgb_mean = torch.tensor([0.485, 0.456, 0.406]) # Fixed values for PyTorch pretrained models\n",
    "rgb_std = torch.tensor([0.229, 0.224, 0.225])\n",
    "\n",
    "class Image(nn.Module):\n",
    "    def __init__(self, img=None, optimizable=True, img_shape=[64,64], jit_max=2, angle_max=2.0, shift_ini_i=0, shift_ini_j=0, random_seed=42):\n",
    "        super(Image,self).__init__()\n",
    "        \n",
    "        self.img_shape = img_shape\n",
    "        \n",
    "        if type(img)==type(None):\n",
    "            torch.manual_seed(random_seed)\n",
    "            self.img = torch.rand([1, 3] + self.img_shape)\n",
    "        else:\n",
    "            self.img = img\n",
    "            self.img = self.preprocess()\n",
    "            self.img = self.jitter_transform(self.img,0,shift_ini_i, shift_ini_j)\n",
    "        if optimizable == True:\n",
    "            self.img = nn.Parameter(self.img)\n",
    "         \n",
    "        self.jit_i = 0\n",
    "        self.jit_j = 0\n",
    "        self.jit_max = jit_max\n",
    "        self.angle = 0.0\n",
    "        self.angle_max = angle_max\n",
    "\n",
    "        \n",
    "    def preprocess(self):\n",
    "        with torch.no_grad():\n",
    "            transforms = torchvision.transforms.Compose([\n",
    "                torchvision.transforms.ToPILImage(),\n",
    "                torchvision.transforms.Resize(self.img_shape),\n",
    "                torchvision.transforms.ToTensor(),\n",
    "            ])\n",
    "            return transforms(self.img).unsqueeze(0)\n",
    "            \n",
    "\n",
    "    def postprocess(self):\n",
    "        with torch.no_grad():\n",
    "            img = self.img.data[0].to(rgb_std.device).clone()\n",
    "            img.clamp_(0, 1)\n",
    "            return torchvision.transforms.ToPILImage()(img.permute(1, 2, 0).permute(2, 0, 1))\n",
    "          \n",
    "    def jitter_transform(self,img,angle,jit_i, jit_j):\n",
    "        return torchvision.transforms.functional.affine(img, angle=angle, translate=(jit_i/self.img_shape[1], jit_j/self.img_shape[0]), scale=1., shear=[0.0,0.0])\n",
    "        \n",
    "    def jittered_image(self):\n",
    "        with torch.no_grad():\n",
    "            jit_max = 2\n",
    "            temp = np.random.standard_normal(2)*2.0\n",
    "            self.jit_i += temp[0]\n",
    "            self.jit_j += temp[1]\n",
    "\n",
    "            self.angle += np.random.standard_normal(1)[0]*1.0\n",
    "            self.angle = np.clip(self.angle,-self.angle_max,self.angle_max)\n",
    "            self.jit_i, self.jit_j = np.clip([self.jit_i, self.jit_j],-self.jit_max,self.jit_max)#.astype(int)\n",
    "            print(self.angle, self.jit_i, self.jit_j, temp)\n",
    "            return self.jitter_transform(self.img.data,self.angle,self.jit_i, self.jit_j) \n",
    "        \n",
    "    def forward(self, jitter=False):\n",
    "        self.img.data.clamp_(0, 1)\n",
    "        if jitter:\n",
    "            return self.jittered_image().to(device)\n",
    "        else:\n",
    "            return self.img.to(device)\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aYluJ_Lowwhe",
   "metadata": {
    "id": "aYluJ_Lowwhe"
   },
   "source": [
    "# Pretrained network\n",
    "\n",
    "Here, I use the VGG16 network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "94d2ec43-9d5a-4c6c-8763-389e1d1886fd",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 644,
     "referenced_widgets": [
      "a4b7374c1fce43a5aaf28728f7a72112",
      "df848183e14146dc9551b1ab26670a24",
      "7c0d2b5beb6a4e20b03dd1ef288657c2",
      "8ea8e6f74d454586889059a72887d213",
      "3976dac84d7442b1ad46235f560a5200",
      "63151ad892c044a185f41ecd4eb4c8a7",
      "cf247979241d4edb9ba5ec291fcbe245",
      "45d714d190b54792bb2621b9b4aed840"
     ]
    },
    "executionInfo": {
     "elapsed": 7034,
     "status": "ok",
     "timestamp": 1626761859384,
     "user": {
      "displayName": "Arthur Bauville",
      "photoUrl": "",
      "userId": "13412020910432312638"
     },
     "user_tz": -540
    },
    "id": "94d2ec43-9d5a-4c6c-8763-389e1d1886fd",
    "outputId": "289f38e5-4353-4ff4-ea4a-7b199ae8e1f2"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Downloading: \"https://download.pytorch.org/models/vgg16-397923af.pth\" to /root/.cache/torch/hub/checkpoints/vgg16-397923af.pth\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a4b7374c1fce43a5aaf28728f7a72112",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=553433881.0), HTML(value='')))"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (1): ReLU(inplace=True)\n",
       "  (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (3): ReLU(inplace=True)\n",
       "  (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (6): ReLU(inplace=True)\n",
       "  (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (8): ReLU(inplace=True)\n",
       "  (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (11): ReLU(inplace=True)\n",
       "  (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (13): ReLU(inplace=True)\n",
       "  (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (15): ReLU(inplace=True)\n",
       "  (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (18): ReLU(inplace=True)\n",
       "  (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (20): ReLU(inplace=True)\n",
       "  (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (22): ReLU(inplace=True)\n",
       "  (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (25): ReLU(inplace=True)\n",
       "  (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (27): ReLU(inplace=True)\n",
       "  (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (29): ReLU(inplace=True)\n",
       "  (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       ")"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pretrained_net = torchvision.models.vgg16(pretrained=True)#.features.to(device).eval()\n",
    "display(pretrained_net.features)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "-1M4iEFLw5y7",
   "metadata": {
    "id": "-1M4iEFLw5y7"
   },
   "source": [
    "# SmallNet class\n",
    "\n",
    "I subset the pretrained network to compute only the required layers and return the feature maps of a small selection of layers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d4d6fc89-75f1-4300-8691-1daca508396a",
   "metadata": {
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1626761859384,
     "user": {
      "displayName": "Arthur Bauville",
      "photoUrl": "",
      "userId": "13412020910432312638"
     },
     "user_tz": -540
    },
    "id": "d4d6fc89-75f1-4300-8691-1daca508396a"
   },
   "outputs": [],
   "source": [
    "class SmallNet(nn.Module):\n",
    "    def __init__(self, pretrained_net, last_layer):\n",
    "        super(SmallNet,self).__init__()\n",
    "        self.net= nn.Sequential(*([torchvision.transforms.Normalize(mean=rgb_mean, std=rgb_std)] + \n",
    "                     [pretrained_net.features[i]\n",
    "                            for i in range(last_layer + 1)])).to(device).eval()\n",
    "\n",
    "        \n",
    "    def forward(self, X, extract_layers, gram=False):\n",
    "        # Passes the image X through the pretrained network and \n",
    "        # returns a list containing the feature maps of layers specified in the list extract_layers\n",
    "        detach = not(X.requires_grad) # We don't want to keep track of the gradients on the content image\n",
    "        feature_maps = {}\n",
    "        for il in range(len(self.net)):\n",
    "            X = self.net[il](X)\n",
    "            if (il-1 in extract_layers): # note: il-1 because I added a normalization layer before the pretrained net in self.net\n",
    "                if detach:\n",
    "                    feature_maps[il-1] = X.clone().detach()\n",
    "                else:\n",
    "                    feature_maps[il-1] = X.clone()\n",
    "        return feature_maps"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "mmG2-_mM4qU2",
   "metadata": {
    "id": "mmG2-_mM4qU2"
   },
   "source": [
    "# Losses class\n",
    "\n",
    "Losses include:\n",
    "\n",
    "- *content loss*: mean squared error (MSE) between the feature maps of the content image and the ones of the generated image. \n",
    "- *style loss*: MSE between Gram matrices of style and generated images\n",
    "- *intensity loss* and *total variation loss*: regularization to avoid spurious noise.\n",
    "\n",
    "Loss can be computed with respect to  several *content* and *style* images at once. Using several images with affine transformations is another way to perform jittering. The inconvenient is that this approach takes more memory, but in exchange, all feature maps and grams matrices for the *content* and *style* images can be precomputed. I implemented the technique described into by [Berger and Memisevic (2015)](https://arxiv.org/abs/1606.01286) to improve the long range consistency of the style inversion. In this technique, additional gram matrices between shifted feature maps are performed to take into account the spatial correlation among feature maps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "49346faf-00f5-4494-94c4-46e461f8125c",
   "metadata": {
    "executionInfo": {
     "elapsed": 428,
     "status": "ok",
     "timestamp": 1626761859809,
     "user": {
      "displayName": "Arthur Bauville",
      "photoUrl": "",
      "userId": "13412020910432312638"
     },
     "user_tz": -540
    },
    "id": "49346faf-00f5-4494-94c4-46e461f8125c"
   },
   "outputs": [],
   "source": [
    "class Losses(nn.Module):\n",
    "    def __init__(self, img_ref, \n",
    "                 content_weight=1.0, style_weight=1.0, tv_weight=0.0, int_weight=0.0, \n",
    "                 alpha=6, beta=1.5):\n",
    "        # img_ref is used to compute a reference total variation and reference intensity\n",
    "        # tv_weight: weight of the total variation regularizer\n",
    "        # int_weight: weight of the intensity regularizer\n",
    "        # alpha: exponent for the intensity regularizer\n",
    "        # beta: exponent for the total variation regularizer\n",
    "        super(Losses,self).__init__()\n",
    "        self.content_weight = content_weight\n",
    "        self.style_weight   = style_weight\n",
    "        self.tv_weight      = tv_weight\n",
    "        self.int_weight     = int_weight\n",
    "\n",
    "        self.content_loss   = 0.0\n",
    "        self.style_loss     = 0.0\n",
    "        self.tv_loss        = 0.0\n",
    "        self.int_loss       = 0.0\n",
    "        self.total_loss     = 0.0\n",
    "\n",
    "        self.last_content_loss   = 1e10\n",
    "        self.last_style_loss     = 1e10\n",
    "        self.last_tv_loss        = 1e10\n",
    "        self.last_int_loss       = 1e10\n",
    "        self.last_clamp_loss       = 0.0\n",
    "        self.last_total_loss     = 1e10\n",
    "        \n",
    "        self.alpha          = alpha\n",
    "        self.beta           = beta\n",
    "        \n",
    "        self.B, self.V      = self.get_regularizer_refs(img_ref)\n",
    "      \n",
    "\n",
    "    def get_content_loss(self, Y_hat, Y, reduction='mean'):\n",
    "        # Mean squared error between generated and content image\n",
    "        loss = 0\n",
    "        count = 0\n",
    "        for key, y in Y.items():\n",
    "            if key in Y_hat.keys():\n",
    "                y_hat = Y_hat[key]\n",
    "                loss += F.mse_loss(y_hat, \n",
    "                             y.detach(),reduction=reduction)\n",
    "                count += 1\n",
    "        return loss/count\n",
    "\n",
    "    def get_gram(self, feature_map, delta=0, dir=0):\n",
    "        # delta is a translation for longd-distance cross correlation, see: https://arxiv.org/pdf/1606.01286.pdf\n",
    "        # dir is the direction (0=x; 1=y) in which the cross correlation is computed\n",
    "        a, b, c, d = feature_map.size()  # a=batch size(=1)\n",
    "        pad = delta\n",
    "        \n",
    "\n",
    "        if delta==0:\n",
    "            features = feature_map.view(a * b, c * d)  # resise F_XL into \\hat F_XL\n",
    "            # G = torch.mm(features, features.t())  # compute the gram product\n",
    "            G = torch.mm(features, features.t())  # compute the gram product\n",
    "        else: \n",
    "            if dir==0:\n",
    "                fm_pad = F.pad(feature_map, [pad,pad,0,0])\n",
    "                fm_minus_delta = fm_pad[:,:,pad-delta : pad-delta+c, :].clone()\n",
    "                fm_plus_delta  = fm_pad[:,:,pad+delta : pad+delta+c, :].clone()\n",
    "            elif dir==1:\n",
    "                fm_pad = F.pad(feature_map, [0,0,pad,pad])\n",
    "                fm_minus_delta = fm_pad[:,:,:, pad-delta : pad-delta+d].clone()\n",
    "                fm_plus_delta  = fm_pad[:,:,:, pad+delta : pad+delta+d].clone()\n",
    "            else: \n",
    "                raise ValueError(f\"unknown dir {dir}, accepted values are 0 or 1\")\n",
    "\n",
    "            fm_minus_delta = feature_map.view(a * b, c * d)  # resise F_XL into \\hat F_XL\n",
    "            fm_plus_delta = feature_map.view(a * b, c * d)\n",
    "            \n",
    "            G = torch.mm(fm_minus_delta, fm_plus_delta.t())  # compute the gram product\n",
    "        return G.div(a * b * c * d)\n",
    "   \n",
    "    \n",
    "    def get_style_loss(self, Y_hat, Y, reduction='sum', deltas=[], stride=1):\n",
    "        # Y_hat is the generated image's feature map\n",
    "        # Y is the style image's feature map\n",
    "        loss = 0\n",
    "        count = 0\n",
    "        for key, y in Y.items():\n",
    "            if key in Y_hat.keys():\n",
    "                y_hat = Y_hat[key]\n",
    "\n",
    "                G = self.get_gram(y_hat)\n",
    "                A = self.get_gram(y)\n",
    "                Lstyle = F.mse_loss(G, A.detach(),reduction='sum')\n",
    "                Lcc = 0\n",
    "                fac_sum = 1.0\n",
    "                for i, delta in enumerate(deltas):\n",
    "                    A_x = self.get_gram(y,delta=delta,dir=0)\n",
    "                    A_y = self.get_gram(y,delta=delta,dir=1)\n",
    "                    \n",
    "                    fac = 1.0/(1.0+i) \n",
    "                    Lcc += fac * 0.5 * ( F.mse_loss(G, A_x.detach(),reduction='sum')\n",
    "                                            + F.mse_loss(G, A_y.detach(),reduction='sum'))\n",
    "                    fac_sum += fac\n",
    "\n",
    "                loss += (Lstyle+Lcc)/fac_sum\n",
    "                count += 1\n",
    "\n",
    "        return loss/count\n",
    "    \n",
    "    def get_regularizer_refs(self, img):\n",
    "        eps = 1e-10\n",
    "        L2 = torch.sqrt(img[:,0,:,:]**2 + img[:,1,:,:]**2 + img[:,2,:,:]**2 + eps)\n",
    "        B = L2.mean()\n",
    "\n",
    "        d_dx = img[:,:,1:,:]-img[:,:,:-1,:]\n",
    "        d_dy = img[:,:,:,1:]-img[:,:,:,:-1]\n",
    "        L2 = torch.sqrt(d_dx[:,:,:,1:]**2 + d_dy[:,:,1:,:]**2 + eps)\n",
    "        V = L2.mean()\n",
    "        return B, V\n",
    "\n",
    "    def get_int_loss(self, img):\n",
    "        # Intensity loss\n",
    "        H = img.shape[2]\n",
    "        W = img.shape[3]\n",
    "        C = img.shape[1]\n",
    "        eps = 1e-10\n",
    "        L2 = torch.sqrt(img[:,0,:,:]**2 + img[:,1,:,:]**2 + img[:,2,:,:]**2 + eps)\n",
    "        \n",
    "        loss = 1./H/W/C/(self.B**self.alpha) * torch.sum(L2**self.alpha)\n",
    "        \n",
    "        return loss\n",
    "\n",
    "    def get_tv_loss(self, img):\n",
    "        # Total variation loss\n",
    "        H = img.shape[2]\n",
    "        W = img.shape[3]\n",
    "        C = img.shape[1]\n",
    "        eps = 1e-10 # avoids accidentally taking the sqrt of a negative number because of rounding errors\n",
    "\n",
    "        # # total variation\n",
    "        d_dx = img[:,:,1:,:]-img[:,:,:-1,:]\n",
    "        d_dy = img[:,:,:,1:]-img[:,:,:,:-1]\n",
    "        # I ignore the first row or column of the image when computing the norm, in order to have vectors with matching sizes\n",
    "        # Thus, d_dx and d_dy are not strictly colocated, but that should be a good enough approximation because neighbouring pixels are correlated\n",
    "        L2 = torch.sqrt(d_dx[:,:,:,1:]**2 + d_dy[:,:,1:,:]**2 + eps)\n",
    "        TV = torch.sum(L2**self.beta) # intensity regularizer\n",
    "\n",
    "        loss = 1./H/W/C/(self.V**self.beta) * TV\n",
    "#         loss = 1./H/W * (torch.sum(d_dx**2) + torch.sum(d_dy**2))\n",
    "        return loss\n",
    "    \n",
    "\n",
    "    def forward(self,img,feature_map_gen, feature_map_content, feature_map_style, content_weights,style_deltas=[]):\n",
    "        self.content_loss, w_sum = 0, 0\n",
    "        for fm_content, w in zip(feature_map_content, content_weights):\n",
    "                self.content_loss += self.get_content_loss(feature_map_gen, fm_content,reduction='mean')        \n",
    "                w_sum += w\n",
    "        self.content_loss /= w_sum\n",
    "\n",
    "        self.style_loss, count = 0, 0\n",
    "        for fm_style in feature_map_style:\n",
    "            self.style_loss += self.get_style_loss(feature_map_gen, fm_style,reduction='sum',deltas=style_deltas)\n",
    "            count += 1\n",
    "        self.style_loss /= count\n",
    "\n",
    "        self.int_loss = self.get_int_loss(img)\n",
    "        self.tv_loss = self.get_tv_loss(img)\n",
    "        \n",
    "        self.total_loss = ( self.content_weight*self.content_loss\n",
    "                    + self.style_weight*self.style_loss \n",
    "                    + self.int_weight*self.int_loss \n",
    "                    + self.tv_weight*self.tv_loss )\n",
    "        \n",
    "        \n",
    "        return self.total_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "_i4eIpMmw-ey",
   "metadata": {
    "id": "_i4eIpMmw-ey"
   },
   "source": [
    "# Device setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "eEA1laPO7gVX",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1626761859809,
     "user": {
      "displayName": "Arthur Bauville",
      "photoUrl": "",
      "userId": "13412020910432312638"
     },
     "user_tz": -540
    },
    "id": "eEA1laPO7gVX",
    "outputId": "5d50df02-56db-4d22-9d10-950863be08ee"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cuda\n",
      "\n",
      "Tesla K80\n",
      "Memory Usage:\n",
      "Allocated: 0.0 GB\n",
      "Cached:    0.0 GB\n"
     ]
    }
   ],
   "source": [
    "# setting device on GPU if available, else CPU\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "print('Using device:', device)\n",
    "print()\n",
    "\n",
    "#Additional Info when using cuda\n",
    "if device.type == 'cuda':\n",
    "    print(torch.cuda.get_device_name(0))\n",
    "    print('Memory Usage:')\n",
    "    print('Allocated:', round(torch.cuda.memory_allocated(0)/1024**3,1), 'GB')\n",
    "    print('Cached:   ', round(torch.cuda.memory_reserved(0)/1024**3,1), 'GB')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cvkQB8w94i4S",
   "metadata": {
    "id": "cvkQB8w94i4S"
   },
   "source": [
    "# Training setup\n",
    "\n",
    "Here, I create *content*, *style* and *generated* images by instantiating the `Image` class. I include several images for *content* to take into account local correlations (alternative to jittering the image). I also take one or several *style* images to extract characteristic features at different scales (see the Results section). I also initialize the optimizer, scheduler and loss functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "1bbaa1ef-6137-49f5-b0c3-c5b179695e86",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 232
    },
    "executionInfo": {
     "elapsed": 9493,
     "status": "ok",
     "timestamp": 1626766005653,
     "user": {
      "displayName": "Arthur Bauville",
      "photoUrl": "",
      "userId": "13412020910432312638"
     },
     "user_tz": -540
    },
    "id": "1bbaa1ef-6137-49f5-b0c3-c5b179695e86",
    "outputId": "1c4b3b26-8631-4c9a-ea22-90e56896e653"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Download images \n",
    "# ===================\n",
    "content_im = skimage.io.imread(\"https://github.com/abauville/Neural_style_transfer/blob/main/Data/IMG_20210617_094559.jpg?raw=true\")\n",
    "style_im = skimage.io.imread(\"https://github.com/abauville/Neural_style_transfer/blob/main/Data/matisse_cat.jpeg?raw=true\")\n",
    "\n",
    "# Show\n",
    "fig, ax = plt.subplots(1,2,figsize=[5,5])\n",
    "plt.sca(ax[0])\n",
    "plt.imshow(content_im); plt.title(\"content\"); _ = plt.axis(\"off\")\n",
    "plt.sca(ax[1])\n",
    "plt.imshow(style_im); plt.title(\"style\"); _ = plt.axis(\"off\")\n",
    "\n",
    "# Choose layers\n",
    "# ===================\n",
    "content_layer = [7]\n",
    "style_layers  = [2, 7, 14, 21, 28]\n",
    "\n",
    "all_layers = list(set(content_layer+style_layers))\n",
    "all_layers.sort()\n",
    "\n",
    "# Generated image\n",
    "# ===================\n",
    "aspect_ratio = content_im.shape[1]/content_im.shape[0]\n",
    "content_res = 512\n",
    "# img_gen = Image(None, optimizable=True, img_shape=[content_res,int(content_res*aspect_ratio)]).to(device) # initialized with random noise\n",
    "# img_gen = Image(None, optimizable=True, img_shape=[content_res,int(content_res*aspect_ratio)]).to(device) # initialized with random noise\n",
    "\n",
    "# Style images\n",
    "# ===================\n",
    "style_list = []\n",
    "style_res_ref = 256\n",
    "for style_res in [style_res_ref]:\n",
    "# for style_res in [128, 256, 512]:\n",
    "    style_list.append(Image(img=style_im, optimizable=False, img_shape=[style_res, style_res],\n",
    "                    shift_ini_i=0, shift_ini_j=0).to(device))\n",
    "\n",
    "style_deltas = np.array([2, 4, 8, 16]) # relative shifts for the long range consistency algorithm of Berger and Memisevic (2015)\n",
    "\n",
    "# Content images\n",
    "# ===================\n",
    "content_list = []\n",
    "content_list_weights = []\n",
    "count = 0\n",
    "fm_content = []\n",
    "for i in [-2,-1,0,1,2]:\n",
    "    for j in [-2,-1,0,1,2]:\n",
    "        content_list.append(Image(img=content_im, optimizable=False, img_shape=[content_res,int(content_res*aspect_ratio)],\n",
    "                                    shift_ini_i=i, shift_ini_j=j).to(device))\n",
    "        content_list_weights.append(1.0/(1.0+np.sqrt(i**2 + j**2)))\n",
    "        if i==0 and j==0:\n",
    "            content_ref = count\n",
    "        count += 1\n",
    "content_list_weights = np.array(content_list_weights) # relative importance of feature maps in the loss calculation\n",
    "\n",
    "\n",
    "img_gen = Image(content_list[content_ref].img[0], optimizable=True, img_shape=[content_res,int(content_res*aspect_ratio)]).to(device) # initialized with random noise# SmallNet\n",
    "\n",
    "# Neural network\n",
    "# ===================\n",
    "net = SmallNet(pretrained_net, all_layers[-1])\n",
    "\n",
    "# Precompute feature maps\n",
    "# ===================\n",
    "fm_style = [net(img_s(), style_layers) for img_s in style_list]\n",
    "fm_content = [net(img_c(), content_layer) for img_c in content_list]\n",
    "\n",
    "# Losses\n",
    "# ===================\n",
    "loss_fn = Losses(style_list[0](),\n",
    "                 content_weight = 0.6,\n",
    "                 style_weight = 1.0,\n",
    "                 tv_weight=20.0, \n",
    "                 int_weight=0.5)\n",
    "\n",
    "# Optimizer, scheduler\n",
    "# ===================\n",
    "optimizer = torch.optim.LBFGS(img_gen.parameters(),lr=1.0)\n",
    "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.8)\n",
    "abs_loss_limit = 1e-3\n",
    "rel_loss_limit = 1e-7"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "NI3n9k9a48ui",
   "metadata": {
    "id": "NI3n9k9a48ui"
   },
   "source": [
    "# Training\n",
    "\n",
    "Here, I optimize the *generated* image and visualize the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "05038f8a-9d12-4d81-9df1-dca0b8be45d1",
   "metadata": {
    "executionInfo": {
     "elapsed": 3,
     "status": "ok",
     "timestamp": 1626766007500,
     "user": {
      "displayName": "Arthur Bauville",
      "photoUrl": "",
      "userId": "13412020910432312638"
     },
     "user_tz": -540
    },
    "id": "05038f8a-9d12-4d81-9df1-dca0b8be45d1"
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(1,1,figsize=[10,10])\n",
    "optimizer = torch.optim.LBFGS(img_gen.parameters(),lr=0.1)\n",
    "def closure():\n",
    "    optimizer.zero_grad()\n",
    "    fm_gen = net(img_gen(), all_layers)\n",
    "\n",
    "    loss = loss_fn(img_gen(), fm_gen, fm_content, fm_style, \n",
    "                   content_list_weights, \n",
    "                   style_deltas=style_deltas)\n",
    "    loss.backward()\n",
    "    # nn.utils.clip_grad_norm_(img_gen.parameters(), 2.0)\n",
    "    nn.utils.clip_grad_value_(img_gen.parameters(), clip_value=1.0)\n",
    "    return loss\n",
    "\n",
    "last_loss = 1e10\n",
    "frame = 0\n",
    "for i in range(101,201):\n",
    "    optimizer.step(closure)\n",
    "    scheduler.step()\n",
    "    \n",
    "    if i%5==0:\n",
    "        with torch.no_grad():\n",
    "            plt.clf()\n",
    "#             plt.imshow(img_gen.postprocess())\n",
    "            plt.imshow(img_gen.postprocess())\n",
    "            \n",
    "            plt.title(f\"epoch {i:02}, content, tv, style, intensity losses:\" + \n",
    "                      f\"{loss_fn.content_weight*loss_fn.content_loss:.2e}, \" + \n",
    "                      f\"{loss_fn.style_weight*loss_fn.style_loss:.2e}, \" + \n",
    "                      f\"{loss_fn.tv_weight*loss_fn.tv_loss:.2e}, \" +\n",
    "                      f\"{loss_fn.int_weight*loss_fn.int_loss:.2e}, \" + \n",
    "                      f\"total:{loss_fn.total_loss:.2e}, abs: {torch.abs(last_loss-loss_fn.total_loss):.2e}\")\n",
    "\n",
    "            clear_output(wait = True)\n",
    "            display(fig)\n",
    "            \n",
    "            plt.savefig(f\"/content/drive/MyDrive/00_Data_science/Neural_style_transfer/Output/res_{style_res_ref}/Frame{frame:05d}\")\n",
    "            frame += 1\n",
    "        \n",
    "            if loss_fn.total_loss<abs_loss_limit:\n",
    "                clear_output(wait = True)\n",
    "                print(f'success: absolute loss limit ({abs_loss_limit:.1e}) reached')\n",
    "                break\n",
    "            if torch.abs(last_loss-loss_fn.total_loss)<rel_loss_limit:\n",
    "                clear_output(wait = True)\n",
    "                print(f'stopped because relative loss limit ({rel_loss_limit:.1e})  was reached')\n",
    "                break\n",
    "\n",
    "            if loss_fn.total_loss.isnan():\n",
    "                print(f'stopped because loss is NaN')\n",
    "                break\n",
    "                \n",
    "    last_loss = loss_fn.total_loss\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffdZULqfqzkP",
   "metadata": {
    "id": "ffdZULqfqzkP"
   },
   "source": [
    "# Results\n",
    "\n",
    "I perform several optimization with identic resolution of the *generated* and *content* images but different resolutions for the style image. As shown in the figure below, the style is expressed as patterns whose characteristic scale is proportional to the resolution. In the rightmost subfigure, I used three style images during the inversion to obtain patterns of different scales.\n",
    "\n",
    "<figure>\n",
    "    <img src=\"https://github.com/abauville/blog/raw/master/images/2021_07_20_neural_style_transfer/Figure_01.png\" alt='neural style transfer with different style resolutions' />\n",
    "    <figcaption>Fig. 1. Results of the neural style transfer optimization using different resolutions of the style image. The characteristic scale of patterns is proportional to the style image's resolution. For the rightmost panel, three images were used simultaneously. </figcaption>\n",
    "</figure>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e99f41fd-e992-41e7-9c0f-6657a3ec6a97",
   "metadata": {
    "executionInfo": {
     "elapsed": 6,
     "status": "aborted",
     "timestamp": 1625471046493,
     "user": {
      "displayName": "Arthur Bauville",
      "photoUrl": "",
      "userId": "13412020910432312638"
     },
     "user_tz": -540
    },
    "id": "e99f41fd-e992-41e7-9c0f-6657a3ec6a97"
   },
   "source": [
    "# Conclusion\n",
    "\n",
    "In this post, I implemented the neural style transfer algorithm of [Gatys et al. (2015)](https://arxiv.org/abs/1412.0035), with the improvements for feature inversion proposed by [Mahendran and Vedaldi (2016)](https://arxiv.org/abs/1512.02017) and long-range consistency improvements proposed [Berger and Memisevic (2015)](https://arxiv.org/abs/1606.01286) for the style computation. I reused the code architecture that I described in a previous blogpost on the [feature inversion algorithm](https://abauville.github.io/blog/deep-learning/pytorch/computer-vision/from%20scratch/2021/07/16/feature-inversion.html). Neural style transfer is a lot of fun to play with, although the algorithm implemented here is computationally expansive. Later improvements fixed this issue by training an additional network to learn the inversion process (e.g. [Johnson et al. (2016)](https://cs.stanford.edu/people/jcjohns/eccv16/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "pJ7G4oWxZ6bq",
   "metadata": {
    "executionInfo": {
     "elapsed": 17,
     "status": "ok",
     "timestamp": 1626762698627,
     "user": {
      "displayName": "Arthur Bauville",
      "photoUrl": "",
      "userId": "13412020910432312638"
     },
     "user_tz": -540
    },
    "id": "pJ7G4oWxZ6bq"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "Blog03_Transfer.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.9.6"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "3976dac84d7442b1ad46235f560a5200": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": "initial"
     }
    },
    "45d714d190b54792bb2621b9b4aed840": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "63151ad892c044a185f41ecd4eb4c8a7": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "7c0d2b5beb6a4e20b03dd1ef288657c2": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "100%",
      "description_tooltip": null,
      "layout": "IPY_MODEL_63151ad892c044a185f41ecd4eb4c8a7",
      "max": 553433881,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_3976dac84d7442b1ad46235f560a5200",
      "value": 553433881
     }
    },
    "8ea8e6f74d454586889059a72887d213": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_45d714d190b54792bb2621b9b4aed840",
      "placeholder": "​",
      "style": "IPY_MODEL_cf247979241d4edb9ba5ec291fcbe245",
      "value": " 528M/528M [00:07&lt;00:00, 72.5MB/s]"
     }
    },
    "a4b7374c1fce43a5aaf28728f7a72112": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_7c0d2b5beb6a4e20b03dd1ef288657c2",
       "IPY_MODEL_8ea8e6f74d454586889059a72887d213"
      ],
      "layout": "IPY_MODEL_df848183e14146dc9551b1ab26670a24"
     }
    },
    "cf247979241d4edb9ba5ec291fcbe245": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "df848183e14146dc9551b1ab26670a24": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}