flood_style_transfer_half_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The neural style transfer implementation is minimally modified from http://pytorch.org/tutorials/advanced/neural_style_tutorial.html.\n",
    "\n",
    "The modifications were essentially condensing all training code into a function (used in the last cell) to easily allow task repetition.\n",
    "\n",
    "The original paper detailing this approach: https://arxiv.org/abs/1508.06576"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.autograd import Variable\n",
    "import torch.optim as optim\n",
    "\n",
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torchvision.transforms as transforms\n",
    "import torchvision.models as models\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "import copy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### In case there's a GPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "use_cuda = torch.cuda.is_available()\n",
    "dtype = torch.cuda.FloatTensor if use_cuda else torch.FloatTensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Define the style transfer loss functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class ContentLoss(nn.Module):\n",
    "\n",
    "    def __init__(self, target, weight):\n",
    "        super(ContentLoss, self).__init__()\n",
    "        # we 'detach' the target content from the tree used\n",
    "        self.target = target.detach() * weight\n",
    "        # to dynamically compute the gradient: this is a stated value,\n",
    "        # not a variable. Otherwise the forward method of the criterion\n",
    "        # will throw an error.\n",
    "        self.weight = weight\n",
    "        self.criterion = nn.MSELoss()\n",
    "\n",
    "    def forward(self, input):\n",
    "        self.loss = self.criterion(input * self.weight, self.target)\n",
    "        self.output = input\n",
    "        return self.output\n",
    "\n",
    "    def backward(self, retain_graph=True):\n",
    "        self.loss.backward(retain_graph=retain_graph)\n",
    "        return self.loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class GramMatrix(nn.Module):\n",
    "\n",
    "    def forward(self, input):\n",
    "        a, b, c, d = input.size()  # a=batch size(=1)\n",
    "        # b=number of feature maps\n",
    "        # (c,d)=dimensions of a f. map (N=c*d)\n",
    "\n",
    "        features = input.view(a * b, c * d)  # resise F_XL into \\hat F_XL\n",
    "\n",
    "        G = torch.mm(features, features.t())  # compute the gram product\n",
    "\n",
    "        # we 'normalize' the values of the gram matrix\n",
    "        # by dividing by the number of element in each feature maps.\n",
    "        return G.div(a * b * c * d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class StyleLoss(nn.Module):\n",
    "\n",
    "    def __init__(self, target, weight):\n",
    "        super(StyleLoss, self).__init__()\n",
    "        self.target = target.detach() * weight\n",
    "        self.weight = weight\n",
    "        self.gram = GramMatrix()\n",
    "        self.criterion = nn.MSELoss()\n",
    "\n",
    "    def forward(self, input):\n",
    "        self.output = input.clone()\n",
    "        self.G = self.gram(input)\n",
    "        self.G.mul_(self.weight)\n",
    "        self.loss = self.criterion(self.G, self.target)\n",
    "        return self.output\n",
    "\n",
    "    def backward(self, retain_graph=True):\n",
    "        self.loss.backward(retain_graph=retain_graph)\n",
    "        return self.loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Upload the PyTorch-implemented, pretrained VGGNet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "cnn = models.vgg19(pretrained=True).features\n",
    "\n",
    "# move it to the GPU if possible:\n",
    "if use_cuda:\n",
    "    cnn = cnn.cuda()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Function to run the front-to-end style transfer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def neural_style_transfer(imsize, content_filepath, style_filepath,\n",
    "                          content_layers_default, style_layers_default,\n",
    "                          trade_off_ratio):\n",
    "    \n",
    "    # desired size of the output image\n",
    "    loader = transforms.Compose([\n",
    "        transforms.Scale(imsize),  # scale imported image\n",
    "        transforms.ToTensor()])  # transform it into a torch tensor\n",
    "\n",
    "\n",
    "    def image_loader(image_name):\n",
    "        image = Image.open(image_name)\n",
    "        image = Variable(loader(image))\n",
    "        # fake batch dimension required to fit network's input dimensions\n",
    "        image = image.unsqueeze(0)\n",
    "        return image\n",
    "\n",
    "\n",
    "    style_img = image_loader(style_filepath).type(dtype)\n",
    "    content_img = image_loader(content_filepath).type(dtype)\n",
    "\n",
    "    assert style_img.size() == content_img.size(), \\\n",
    "        \"we need to import style and content images of the same size\"\n",
    "        \n",
    "    unloader = transforms.ToPILImage()  # reconvert into PIL image\n",
    "\n",
    "    plt.ion()\n",
    "\n",
    "    def imshow(tensor, title=None):\n",
    "        image = tensor.clone().cpu()  # we clone the tensor to not do changes on it\n",
    "        image = image.view(3, imsize, imsize)  # remove the fake batch dimension\n",
    "        image = unloader(image)\n",
    "        plt.imshow(image)\n",
    "        if title is not None:\n",
    "            plt.title(title)\n",
    "            plt.pause(0.001) # pause a bit so that plots are updated\n",
    "\n",
    "\n",
    "    #plt.figure()\n",
    "    #imshow(style_img.data, title='Style Image')\n",
    "\n",
    "    #plt.figure()\n",
    "    #imshow(content_img.data, title='Content Image')\n",
    "\n",
    "\n",
    "    def get_style_model_and_losses(cnn, style_img, content_img,\n",
    "                                   style_weight= trade_off_ratio, content_weight=1,\n",
    "                                   content_layers=content_layers_default,\n",
    "                                   style_layers=style_layers_default):\n",
    "        cnn = copy.deepcopy(cnn)\n",
    "\n",
    "        # just in order to have an iterable access to or list of content/syle\n",
    "        # losses\n",
    "        content_losses = []\n",
    "        style_losses = []\n",
    "\n",
    "        model = nn.Sequential()  # the new Sequential module network\n",
    "        gram = GramMatrix()  # we need a gram module in order to compute style targets\n",
    "\n",
    "        # move these modules to the GPU if possible:\n",
    "        if use_cuda:\n",
    "            model = model.cuda()\n",
    "            gram = gram.cuda()\n",
    "\n",
    "        i = 1\n",
    "        for layer in list(cnn):\n",
    "            if isinstance(layer, nn.Conv2d):\n",
    "                name = \"conv_\" + str(i)\n",
    "                model.add_module(name, layer)\n",
    "\n",
    "                if name in content_layers:\n",
    "                    # add content loss:\n",
    "                    target = model(content_img).clone()\n",
    "                    content_loss = ContentLoss(target, content_weight)\n",
    "                    model.add_module(\"content_loss_\" + str(i), content_loss)\n",
    "                    content_losses.append(content_loss)\n",
    "\n",
    "                if name in style_layers:\n",
    "                    # add style loss:\n",
    "                    target_feature = model(style_img).clone()\n",
    "                    target_feature_gram = gram(target_feature)\n",
    "                    style_loss = StyleLoss(target_feature_gram, style_weight)\n",
    "                    model.add_module(\"style_loss_\" + str(i), style_loss)\n",
    "                    style_losses.append(style_loss)\n",
    "\n",
    "            if isinstance(layer, nn.ReLU):\n",
    "                name = \"relu_\" + str(i)\n",
    "                model.add_module(name, layer)\n",
    "\n",
    "                if name in content_layers:\n",
    "                    # add content loss:\n",
    "                    target = model(content_img).clone()\n",
    "                    content_loss = ContentLoss(target, content_weight)\n",
    "                    model.add_module(\"content_loss_\" + str(i), content_loss)\n",
    "                    content_losses.append(content_loss)\n",
    "\n",
    "                if name in style_layers:\n",
    "                    # add style loss:\n",
    "                    target_feature = model(style_img).clone()\n",
    "                    target_feature_gram = gram(target_feature)\n",
    "                    style_loss = StyleLoss(target_feature_gram, style_weight)\n",
    "                    model.add_module(\"style_loss_\" + str(i), style_loss)\n",
    "                    style_losses.append(style_loss)\n",
    "\n",
    "                i += 1\n",
    "\n",
    "            if isinstance(layer, nn.MaxPool2d):\n",
    "                name = \"pool_\" + str(i)\n",
    "                model.add_module(name, layer)  # ***\n",
    "\n",
    "        return model, style_losses, content_losses\n",
    "    \n",
    "    input_img = content_img.clone()\n",
    "    # if you want to use a white noise instead uncomment the below line:\n",
    "    # input_img = Variable(torch.randn(content_img.data.size())).type(dtype)\n",
    "\n",
    "    # add the original input image to the figure:\n",
    "    #plt.figure()\n",
    "    #imshow(input_img.data, title='Input Image')\n",
    "    \n",
    "    def get_input_param_optimizer(input_img):\n",
    "        # this line to show that input is a parameter that requires a gradient\n",
    "        input_param = nn.Parameter(input_img.data)\n",
    "        optimizer = optim.LBFGS([input_param])\n",
    "        return input_param, optimizer\n",
    "    \n",
    "    def run_style_transfer(cnn, content_img, style_img, input_img, num_steps=300,\n",
    "                           style_weight=trade_off_ratio, content_weight=1):\n",
    "        \"\"\"Run the style transfer.\"\"\"\n",
    "        #print('Building the style transfer model..')\n",
    "        model, style_losses, content_losses = get_style_model_and_losses(cnn,\n",
    "            style_img, content_img, style_weight, content_weight)\n",
    "        input_param, optimizer = get_input_param_optimizer(input_img)\n",
    "\n",
    "        #print('Optimizing..')\n",
    "        #print()\n",
    "        run = [0]\n",
    "        while run[0] <= num_steps:\n",
    "\n",
    "            def closure():\n",
    "                # correct the values of updated input image\n",
    "                input_param.data.clamp_(0, 1)\n",
    "\n",
    "                optimizer.zero_grad()\n",
    "                model(input_param)\n",
    "                style_score = 0\n",
    "                content_score = 0\n",
    "\n",
    "                for sl in style_losses:\n",
    "                    style_score += sl.backward()\n",
    "                for cl in content_losses:\n",
    "                    content_score += cl.backward()\n",
    "\n",
    "                run[0] += 1\n",
    "                #if run[0] % 50 == 0:\n",
    "                    #print()\n",
    "                    #print(\"For the %0.6f\" % run[0] + 'th iteration...')\n",
    "                    #print('Style Loss = {:4f} and Content Loss = {:4f}'.format(style_score.data[0],\n",
    "                    #                                                           content_score.data[0]))\n",
    "                    #print()\n",
    "                    \n",
    "\n",
    "                return style_score + content_score\n",
    "                    \n",
    "\n",
    "            optimizer.step(closure)\n",
    "\n",
    "        # a last correction...\n",
    "        input_param.data.clamp_(0, 1)\n",
    "\n",
    "        return input_param.data\n",
    "    \n",
    "    output = run_style_transfer(cnn, content_img, style_img, input_img)\n",
    "\n",
    "    #plt.figure()\n",
    "    #imshow(output, title='Output Image')\n",
    "\n",
    "    # sphinx_gallery_thumbnail_number = 4\n",
    "    #plt.ioff()\n",
    "    #plt.show\n",
    "    \n",
    "    return(output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Function to evaluate the loss values on the true after images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def evaluate_performance(imsize, style_img, content_img,\n",
    "                         content_layers_default, style_layers_default):\n",
    "\n",
    "    loader = transforms.Compose([transforms.Scale(imsize),  # scale imported image\n",
    "                                 transforms.ToTensor()])  # transform it into a torch tensor\n",
    "    def image_loader(image_name):\n",
    "        image = Image.open(image_name)\n",
    "        image = Variable(loader(image))\n",
    "        # fake batch dimension required to fit network's input dimensions\n",
    "        image = image.unsqueeze(0)\n",
    "        return image\n",
    "    \n",
    "    style_img = image_loader(style_img).type(dtype)\n",
    "    content_img = Variable(content_img)\n",
    "\n",
    "    unloader = transforms.ToPILImage()  # reconvert into PIL image\n",
    "\n",
    "    plt.ion()\n",
    "\n",
    "    def imshow(tensor, title=None):\n",
    "        image = tensor.clone().cpu()  # we clone the tensor to not do changes on it\n",
    "        image = image.view(3, imsize, imsize)  # remove the fake batch dimension\n",
    "        image = unloader(image)\n",
    "        plt.imshow(image)\n",
    "        if title is not None:\n",
    "            plt.title(title)\n",
    "        plt.pause(0.001) # pause a bit so that plots are updated\n",
    "        \n",
    "    cnn = models.vgg19(pretrained=True).features\n",
    "\n",
    "\n",
    "    def get_style_model_and_losses(cnn, style_img, content_img,\n",
    "                                   style_weight=1, content_weight=1,\n",
    "                                   content_layers=content_layers_default,\n",
    "                                   style_layers=style_layers_default):\n",
    "        cnn = copy.deepcopy(cnn)\n",
    "\n",
    "        # just in order to have an iterable access to or list of content/syle\n",
    "        # losses\n",
    "        content_losses = []\n",
    "        style_losses = []\n",
    "\n",
    "        model = nn.Sequential()  # the new Sequential module network\n",
    "        gram = GramMatrix()  # we need a gram module in order to compute style targets\n",
    "\n",
    "        # move these modules to the GPU if possible:\n",
    "        if use_cuda:\n",
    "            model = model.cuda()\n",
    "            gram = gram.cuda()\n",
    "\n",
    "        i = 1\n",
    "        for layer in list(cnn):\n",
    "            if isinstance(layer, nn.Conv2d):\n",
    "                name = \"conv_\" + str(i)\n",
    "                model.add_module(name, layer)\n",
    "\n",
    "                if name in content_layers:\n",
    "                    # add content loss:\n",
    "                    target = model(style_img).clone()\n",
    "                    content_loss = ContentLoss(target, content_weight)\n",
    "                    model.add_module(\"content_loss_\" + str(i), content_loss)\n",
    "                    content_losses.append(content_loss)\n",
    "\n",
    "                if name in style_layers:\n",
    "                    # add style loss:\n",
    "                    target_feature = model(style_img).clone()\n",
    "                    target_feature_gram = gram(target_feature)\n",
    "                    style_loss = StyleLoss(target_feature_gram, style_weight)\n",
    "                    model.add_module(\"style_loss_\" + str(i), style_loss)\n",
    "                    style_losses.append(style_loss)\n",
    "\n",
    "            if isinstance(layer, nn.ReLU):\n",
    "                name = \"relu_\" + str(i)\n",
    "                model.add_module(name, layer)\n",
    "\n",
    "                if name in content_layers:\n",
    "                    # add content loss:\n",
    "                    target = model(style_img).clone()\n",
    "                    content_loss = ContentLoss(target, content_weight)\n",
    "                    model.add_module(\"content_loss_\" + str(i), content_loss)\n",
    "                    content_losses.append(content_loss)\n",
    "\n",
    "                if name in style_layers:\n",
    "                    # add style loss:\n",
    "                    target_feature = model(style_img).clone()\n",
    "                    target_feature_gram = gram(target_feature)\n",
    "                    style_loss = StyleLoss(target_feature_gram, style_weight)\n",
    "                    model.add_module(\"style_loss_\" + str(i), style_loss)\n",
    "                    style_losses.append(style_loss)\n",
    "\n",
    "                i += 1\n",
    "\n",
    "            if isinstance(layer, nn.MaxPool2d):\n",
    "                name = \"pool_\" + str(i)\n",
    "                model.add_module(name, layer)  # ***\n",
    "\n",
    "        return model, style_losses, content_losses\n",
    "    \n",
    "    def get_input_param_optimizer(input_img):\n",
    "        # this line to show that input is a parameter that requires a gradient\n",
    "        input_param = nn.Parameter(input_img.data)\n",
    "        optimizer = optim.LBFGS([input_param], lr = 0)\n",
    "        return input_param, optimizer\n",
    "    \n",
    "    cnn = copy.deepcopy(cnn)\n",
    "    \n",
    "    def run_style_transfer(cnn, content_image, style_image, input_image, num_steps=1,\n",
    "                           style_weight=1, content_weight=1):\n",
    "        \"\"\"Run the style transfer.\"\"\"\n",
    "        #print('Set up...')\n",
    "        model, style_losses, content_losses = get_style_model_and_losses(cnn,\n",
    "            style_image, content_image, style_weight, content_weight)\n",
    "        input_param, optimizer = get_input_param_optimizer(input_image)\n",
    "\n",
    "        #print('Computing loss between output and true image...')\n",
    "        run = [0]\n",
    "        while run[0] <= num_steps:\n",
    "\n",
    "            def closure():\n",
    "                # correct the values of updated input image\n",
    "                input_param.data.clamp_(0, 1)\n",
    "\n",
    "                optimizer.zero_grad()\n",
    "                model(input_param)\n",
    "                style_score = 0\n",
    "                content_score = 0\n",
    "\n",
    "                for sl in style_losses:\n",
    "                    style_score += sl.backward()\n",
    "                for cl in content_losses:\n",
    "                    content_score += cl.backward()\n",
    "                \n",
    "                if run[0] % 50 == 1:\n",
    "                    #print(\"run {}:\".format(run))\n",
    "                    #print('Style Loss : {:4f} Content Loss: {:4f}'.format(\n",
    "                    #    style_score.data[0], content_score.data[0]))\n",
    "                    #print()\n",
    "                    true_style_loss_cont.append(style_score.data[0])\n",
    "                    true_content_loss_cont.append(content_score.data[0])\n",
    "                run[0] += 1\n",
    "                \n",
    "                return style_score + content_score\n",
    "\n",
    "            optimizer.step(closure)\n",
    "        \n",
    "        # a last correction...\n",
    "        input_param.data.clamp_(0, 1)\n",
    "\n",
    "        return input_param.data\n",
    "    \n",
    "    output = run_style_transfer(cnn, content_img, style_img, content_img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Defining the hyperparameters we will loop over"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "style_coefficient_list = [10**2, 10**3, 10**4, 10**5]\n",
    "\n",
    "style_depth_list = [['conv_1'],\n",
    "                    ['conv_1', 'conv_2'],\n",
    "                    ['conv_1', 'conv_2', 'conv_3'],\n",
    "                    ['conv_1', 'conv_2', 'conv_3', 'conv_4'],\n",
    "                    ['conv_1', 'conv_2', 'conv_3', 'conv_4', 'conv_5']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Defining the image size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "side_length_pixel_count = 250"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Getting the images that will be used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['processed_simplified/11_content.jpg',\n",
       " 'processed_simplified/12_content.jpg',\n",
       " 'processed_simplified/13_content.jpg',\n",
       " 'processed_simplified/14_content.jpg',\n",
       " 'processed_simplified/15_content.jpg',\n",
       " 'processed_simplified/16_content.jpg',\n",
       " 'processed_simplified/17_content.jpg',\n",
       " 'processed_simplified/18_content.jpg',\n",
       " 'processed_simplified/19_content.jpg',\n",
       " 'processed_simplified/20_content.jpg']"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "file_numbers = np.arange(11, 21)\n",
    "file_numbers = file_numbers.astype(str)\n",
    "\n",
    "file_subfix = np.repeat('_content.jpg', 10)\n",
    "file_prefix = np.repeat('processed_simplified/', 10)\n",
    "\n",
    "file_list = []\n",
    "\n",
    "for number in np.arange(0, 10):\n",
    "    \n",
    "    file_list.append(file_prefix.tolist()[number] + file_numbers.tolist()[number] + file_subfix.tolist()[number])\n",
    "    \n",
    "file_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Find out what hyperparameters generate the best flood images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New hyperparameter combinations are being ran...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Applications/anaconda3/lib/python3.6/site-packages/torchvision-0.2.0-py3.6.egg/torchvision/transforms/transforms.py:156: UserWarning: The use of the transforms.Scale transform is deprecated, please use transforms.Resize instead.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For style depth ['conv_1'] and style coefficient 100.000000\n",
      "The average custom loss value on the first half of the data is: 0.001286\n",
      "\n",
      "New hyperparameter combinations are being ran...\n",
      "For style depth ['conv_1', 'conv_2'] and style coefficient 100.000000\n",
      "The average custom loss value on the first half of the data is: nan\n",
      "\n",
      "New hyperparameter combinations are being ran...\n",
      "For style depth ['conv_1', 'conv_2', 'conv_3'] and style coefficient 100.000000\n",
      "The average custom loss value on the first half of the data is: 0.043875\n",
      "\n",
      "New hyperparameter combinations are being ran...\n",
      "For style depth ['conv_1', 'conv_2', 'conv_3', 'conv_4'] and style coefficient 100.000000\n",
      "The average custom loss value on the first half of the data is: nan\n",
      "\n",
      "New hyperparameter combinations are being ran...\n",
      "For style depth ['conv_1', 'conv_2', 'conv_3', 'conv_4', 'conv_5'] and style coefficient 100.000000\n",
      "The average custom loss value on the first half of the data is: 0.007354\n",
      "\n",
      "New hyperparameter combinations are being ran...\n",
      "For style depth ['conv_1'] and style coefficient 1000.000000\n",
      "The average custom loss value on the first half of the data is: 0.102246\n",
      "\n",
      "New hyperparameter combinations are being ran...\n",
      "For style depth ['conv_1', 'conv_2'] and style coefficient 1000.000000\n",
      "The average custom loss value on the first half of the data is: 0.097313\n",
      "\n",
      "New hyperparameter combinations are being ran...\n",
      "For style depth ['conv_1', 'conv_2', 'conv_3'] and style coefficient 1000.000000\n",
      "The average custom loss value on the first half of the data is: 0.600173\n",
      "\n",
      "New hyperparameter combinations are being ran...\n",
      "For style depth ['conv_1', 'conv_2', 'conv_3', 'conv_4'] and style coefficient 1000.000000\n",
      "The average custom loss value on the first half of the data is: 0.000821\n",
      "\n",
      "New hyperparameter combinations are being ran...\n",
      "For style depth ['conv_1', 'conv_2', 'conv_3', 'conv_4', 'conv_5'] and style coefficient 1000.000000\n",
      "The average custom loss value on the first half of the data is: 0.000906\n",
      "\n",
      "New hyperparameter combinations are being ran...\n",
      "For style depth ['conv_1'] and style coefficient 10000.000000\n",
      "The average custom loss value on the first half of the data is: 0.109960\n",
      "\n",
      "New hyperparameter combinations are being ran...\n",
      "For style depth ['conv_1', 'conv_2'] and style coefficient 10000.000000\n",
      "The average custom loss value on the first half of the data is: 0.474601\n",
      "\n",
      "New hyperparameter combinations are being ran...\n",
      "For style depth ['conv_1', 'conv_2', 'conv_3'] and style coefficient 10000.000000\n",
      "The average custom loss value on the first half of the data is: 0.000746\n",
      "\n",
      "New hyperparameter combinations are being ran...\n",
      "For style depth ['conv_1', 'conv_2', 'conv_3', 'conv_4'] and style coefficient 10000.000000\n",
      "The average custom loss value on the first half of the data is: 0.000908\n",
      "\n",
      "New hyperparameter combinations are being ran...\n",
      "For style depth ['conv_1', 'conv_2', 'conv_3', 'conv_4', 'conv_5'] and style coefficient 10000.000000\n",
      "The average custom loss value on the first half of the data is: 0.000918\n",
      "\n",
      "New hyperparameter combinations are being ran...\n",
      "For style depth ['conv_1'] and style coefficient 100000.000000\n",
      "The average custom loss value on the first half of the data is: 0.000607\n",
      "\n",
      "New hyperparameter combinations are being ran...\n",
      "For style depth ['conv_1', 'conv_2'] and style coefficient 100000.000000\n",
      "The average custom loss value on the first half of the data is: 0.000615\n",
      "\n",
      "New hyperparameter combinations are being ran...\n",
      "For style depth ['conv_1', 'conv_2', 'conv_3'] and style coefficient 100000.000000\n",
      "The average custom loss value on the first half of the data is: 0.000902\n",
      "\n",
      "New hyperparameter combinations are being ran...\n",
      "For style depth ['conv_1', 'conv_2', 'conv_3', 'conv_4'] and style coefficient 100000.000000\n",
      "The average custom loss value on the first half of the data is: 0.000923\n",
      "\n",
      "New hyperparameter combinations are being ran...\n",
      "For style depth ['conv_1', 'conv_2', 'conv_3', 'conv_4', 'conv_5'] and style coefficient 100000.000000\n",
      "The average custom loss value on the first half of the data is: 0.000919\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for style_coefficient in style_coefficient_list:\n",
    "    \n",
    "    for style_depth in style_depth_list:\n",
    "        \n",
    "        print('New hyperparameter combinations are being ran...')\n",
    "        \n",
    "        true_style_loss_cont = []\n",
    "        true_content_loss_cont = []\n",
    "        \n",
    "        for image_i in file_list:\n",
    "            \n",
    "            output_img = neural_style_transfer(side_length_pixel_count, image_i,\n",
    "                                               \"processed_simplified/flood_style.jpg\",\n",
    "                                               ['conv_4'], style_depth, style_coefficient)\n",
    "            \n",
    "            image_i_style = (image_i[:-11] + 'style.jpg')\n",
    "\n",
    "            evaluate_performance(side_length_pixel_count, image_i_style, output_img,\n",
    "                                 ['conv_4'], ['conv_1', 'conv_2', 'conv_3', 'conv_4', 'conv_5'])\n",
    "            \n",
    "        true_content_loss_array = np.asarray(true_content_loss_cont)\n",
    "        true_style_loss_array = np.asarray(true_style_loss_cont)\n",
    "        custom_loss = np.multiply(true_content_loss_array, true_style_loss_array)\n",
    "        first_half_custom_loss_aver = np.mean(custom_loss)\n",
    "        \n",
    "        print('For style depth ' + str(style_depth) + ' and style coefficient %0.6f' % style_coefficient)\n",
    "        print('The average custom loss value on the first half of the data is: %0.6f' % first_half_custom_loss_aver)\n",
    "        print('')"
   ]
  }
 ],
 "metadata": {
  "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}