Recombination_Methods.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Play around with different recombination methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import random\n",
    "import torch\n",
    "import torch.nn.parallel\n",
    "import torch.optim as optim\n",
    "import torch.utils.data\n",
    "import torchvision.datasets as dset\n",
    "import torchvision.transforms as transforms\n",
    "import torchvision.utils as vutils\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.animation as animation\n",
    "from IPython.display import HTML\n",
    "from numpy.random import randint\n",
    "import scipy.stats as stats\n",
    "\n",
    "# save images\n",
    "from torchvision.utils import save_image\n",
    "img_save_path = './plots/'\n",
    "os.makedirs(img_save_path, exist_ok=True)\n",
    "\n",
    "from CAN.parameters import *\n",
    "from CAN.dataloader_wikiart import *\n",
    "from CAN.model_CAN_16_9 import * \n",
    "\n",
    "from deap import base, creator, tools, algorithms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Set random seed for reproducibility\n",
    "manualSeed = 3\n",
    "#manualSeed = random.randint(1, 10000) # use if you want new results\n",
    "print(\"Random Seed: \", manualSeed)\n",
    "random.seed(manualSeed)\n",
    "torch.manual_seed(manualSeed)\n",
    "np.random.seed(manualSeed)\n",
    "\n",
    "\n",
    "# Decide which device we want to run on\n",
    "device = torch.device(\"cuda:0\" if (torch.cuda.is_available() and ngpu > 0) else \"cpu\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### load model\n",
    "\n",
    "# Create the generator\n",
    "netG = Generator(ngpu).to(device)\n",
    "\n",
    "# Setup Adam optimizers for G\n",
    "optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999))\n",
    "\n",
    "# Path to model parameters\n",
    "PATH_GEN = './CAN/models/GEN_16_9.pth'\n",
    "\n",
    "# load checkpoint\n",
    "checkpoint = torch.load(PATH_GEN, map_location=torch.device('cpu'))\n",
    "netG.load_state_dict(checkpoint['model_state_dict'])\n",
    "optimizerG.load_state_dict(checkpoint['optimizer_state_dict'])\n",
    "\n",
    "# set model to evaluation\n",
    "netG.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## deap setup\n",
    "\n",
    "# maximation, one objective\n",
    "creator.create(\"FitnessMax\", base.Fitness, weights=(1.0,))\n",
    "creator.create(\"Individual\", list, fitness=creator.FitnessMax)\n",
    "\n",
    "# set up individuals, random normal distribution\n",
    "toolbox = base.Toolbox()\n",
    "toolbox.register(\"attribute\", np.random.normal)\n",
    "toolbox.register(\"individual\", tools.initRepeat, creator.Individual,\n",
    "                 toolbox.attribute, n=nz)\n",
    "toolbox.register(\"population\", tools.initRepeat, list, toolbox.individual)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Use selfmade functions for OnePoint and Interpolation for more direct handling\n",
    "\n",
    "def crossover(p1, p2, pt):\n",
    "    # select crossover point that is not on the end of the string\n",
    "    #pt = randint(10, p2.size()[0]-11)\n",
    "    # perform crossover\n",
    "    c1 = torch.cat((p1[:pt], p2[pt:]))\n",
    "    c2 = torch.cat((p2[:pt], p1[pt:]))\n",
    "    return c1, c2\n",
    "\n",
    "def Interpolation(ind1, ind2, p = 0.5):\n",
    "    \"\"\"Executes a whole arithmetic crossover on the two input individuals (= two parents namely parent1 and parent 2) \n",
    "    :returns: A tuple of two children.\n",
    "    \"\"\"\n",
    "    return ind1*p + ind2*(1-p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## start individuals, 2 parents\n",
    "genes = torch.randn(2, nz, 1, 1, device=device)\n",
    "\n",
    "# for deap setup\n",
    "# population\n",
    "pop = toolbox.population(n=2)\n",
    "\n",
    "for i in range(2):\n",
    "    ind = genes[i].tolist()\n",
    "    #flatten lists\n",
    "    ind = [item for sublist in ind for item in sublist]\n",
    "    ind = [item for sublist in ind for item in sublist]\n",
    "    pop[i] = (creator.Individual(ind))\n",
    "\n",
    "img_list = []\n",
    "\n",
    "with torch.no_grad():\n",
    "    fake = netG(genes).detach().cpu()\n",
    "    img_list.append(vutils.make_grid(fake, padding=2, normalize=True))\n",
    "    save_image(fake.data, img_save_path + 'Recombination/evolution_0.png', normalize=True)\n",
    "\n",
    "# plot them\n",
    "plt.figure(figsize=(15,15))\n",
    "plt.axis(\"off\")\n",
    "plt.title(\"Start Images\")\n",
    "plt.imshow(np.transpose(vutils.make_grid(fake, padding=2, normalize=True),(1,2,0)))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Part 1: Check individual methods:\n",
    "\n",
    "\n",
    "## OnePoint Crossover\n",
    "\n",
    "children_OnePoint = []\n",
    "# one-point\n",
    "for i in range(9):\n",
    "    c1, c2 = crossover(genes[0], genes[1], pt = i*10+10)\n",
    "    children_OnePoint.append(c1)\n",
    "    children_OnePoint.append(c2)\n",
    "\n",
    "    with torch.no_grad():\n",
    "        fake = netG(torch.stack((c1, c2), 0)).detach().cpu()\n",
    "        img_list.append(vutils.make_grid(fake, padding=2, normalize=True))\n",
    "        save_image(fake.data, img_save_path + 'Recombination/OnePoint/evolution_%d.png' % (i+1), normalize=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Interpolation\n",
    "\n",
    "children_Interpolation = []\n",
    "# one-point\n",
    "for i in range(9):\n",
    "    c1 = Interpolation(genes[0], genes[1], p = (i*10+10)/100)\n",
    "    children_Interpolation.append(c1)\n",
    "\n",
    "    with torch.no_grad():\n",
    "        fake = netG(c1.view(1,nz,1,1)).detach().cpu()\n",
    "        img_list.append(vutils.make_grid(fake, padding=2, normalize=True))\n",
    "        save_image(fake.data, img_save_path + 'Recombination/Interpolation/evolution_%d.png' % (i+1), normalize=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Two Point Crossover, random\n",
    "\n",
    "for i in range(9):\n",
    "\n",
    "    child1, child2 = [toolbox.clone(ind) for ind in (pop[0], pop[1])]\n",
    "    tools.cxTwoPoint(child1, child2)\n",
    "\n",
    "    with torch.no_grad():\n",
    "                new_genes = torch.tensor([child1, child2])\n",
    "                new_genes = new_genes.view(2,nz,1,1)\n",
    "                fake = netG(new_genes.float()).detach().cpu()\n",
    "                img_list.append(vutils.make_grid(fake, padding=2, normalize=True))\n",
    "                save_image(fake.data, img_save_path + 'Recombination/TwoPoint/evolution_%d.png' % (i+1), normalize=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## uniform crossover, random\n",
    "\n",
    "for i in range(9):\n",
    "\n",
    "    child1, child2 = [toolbox.clone(ind) for ind in (pop[0], pop[1])]\n",
    "    tools.cxUniform(child1, child2, indpb = (i*10+10)/100)\n",
    "\n",
    "    with torch.no_grad():\n",
    "                new_genes = torch.tensor([child1, child2])\n",
    "                new_genes = new_genes.view(2,nz,1,1)\n",
    "                fake = netG(new_genes.float()).detach().cpu()\n",
    "                img_list.append(vutils.make_grid(fake, padding=2, normalize=True))\n",
    "                save_image(fake.data, img_save_path + 'Recombination/Uniform/evolution_%d.png' % (i+1), normalize=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Blend crossover\n",
    "## lead to genes out of expected distribution!\n",
    "\n",
    "for i in range(9):\n",
    "\n",
    "    child1, child2 = [toolbox.clone(ind) for ind in (pop[0], pop[1])]\n",
    "    tools.cxBlend(child1, child2, alpha = (i*10+10)/200)\n",
    "    # max alpha = 0.5\n",
    "\n",
    "    with torch.no_grad():\n",
    "                new_genes = torch.tensor([child1, child2])\n",
    "                new_genes = new_genes.view(2,nz,1,1)\n",
    "                fake = netG(new_genes.float()).detach().cpu()\n",
    "                img_list.append(vutils.make_grid(fake, padding=2, normalize=True))\n",
    "                save_image(fake.data, img_save_path + 'Recombination/Blend/evolution_%d.png' % (i+1), normalize=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### part 2: main experiment, try for several parents:\n",
    "\n",
    "\n",
    "def experiment(examples = 5):\n",
    "    \n",
    "    img_list = []\n",
    "\n",
    "    for i in range(examples):\n",
    "\n",
    "        ## start individuals\n",
    "        genes = torch.randn(2, nz, 1, 1, device=device)\n",
    "\n",
    "        with torch.no_grad():\n",
    "            fake = netG(genes).detach().cpu()\n",
    "            img_list.append(vutils.make_grid(fake, padding=2, normalize=True))\n",
    "            save_image(fake.data, img_save_path + 'Recombination/Experiment/evolution_%d.png' % (i), normalize=True)\n",
    "\n",
    "        \n",
    "        ### recombinations\n",
    "\n",
    "        # Interpolation\n",
    "        for j in range(9):\n",
    "            c1 = Interpolation(genes[0], genes[1], p = (j*10+10)/100)\n",
    "            children_Interpolation.append(c1)\n",
    "\n",
    "            with torch.no_grad():\n",
    "                fake = netG(c1.view(1,nz,1,1)).detach().cpu()\n",
    "                img_list.append(vutils.make_grid(fake, padding=2, normalize=True))\n",
    "                save_image(fake.data, img_save_path + 'Recombination/Experiment/evolution_%d_Interpolation_%d.png' % (i, j), normalize=True)\n",
    "\n",
    "\n",
    "        # OnePoint X-Over\n",
    "        for j in range(9):\n",
    "            c1, c2 = crossover(genes[0], genes[1], pt = j*10+10)\n",
    "            children_OnePoint.append(c1)\n",
    "            children_OnePoint.append(c2)\n",
    "\n",
    "            with torch.no_grad():\n",
    "                fake = netG(torch.stack((c1, c2), 0)).detach().cpu()\n",
    "                img_list.append(vutils.make_grid(fake, padding=2, normalize=True))\n",
    "                save_image(fake.data, img_save_path + 'Recombination/Experiment/evolution_%d_OnePoint_%d.png' % (i, j), normalize=True)\n",
    "\n",
    "        \n",
    "        # TwoPoint X-Over, in DEAP Setup\n",
    "        pop = toolbox.population(n=2)\n",
    "\n",
    "        for j in range(2):\n",
    "            ind = genes[j].tolist()\n",
    "            #flatten lists\n",
    "            ind = [item for sublist in ind for item in sublist]\n",
    "            ind = [item for sublist in ind for item in sublist]\n",
    "            pop[j] = (creator.Individual(ind))\n",
    "\n",
    "        for j in range(9):\n",
    "\n",
    "            child1, child2 = [toolbox.clone(ind) for ind in (pop[0], pop[1])]\n",
    "            tools.cxTwoPoint(child1, child2)\n",
    "\n",
    "            with torch.no_grad():\n",
    "                        new_genes = torch.tensor([child1, child2])\n",
    "                        new_genes = new_genes.view(2,nz,1,1)\n",
    "                        fake = netG(new_genes.float()).detach().cpu()\n",
    "                        img_list.append(vutils.make_grid(fake, padding=2, normalize=True))\n",
    "                        save_image(fake.data, img_save_path + 'Recombination/Experiment/evolution_%d_TwoPoint_%d.png' % (i, j), normalize=True)\n",
    "\n",
    "\n",
    "        for j in range(9):\n",
    "\n",
    "            child1, child2 = [toolbox.clone(ind) for ind in (pop[0], pop[1])]\n",
    "            tools.cxUniform(child1, child2, indpb = (i*10+10)/100)\n",
    "            \n",
    "            with torch.no_grad():\n",
    "                        new_genes = torch.tensor([child1, child2])\n",
    "                        new_genes = new_genes.view(2,nz,1,1)\n",
    "                        fake = netG(new_genes.float()).detach().cpu()\n",
    "                        img_list.append(vutils.make_grid(fake, padding=2, normalize=True))\n",
    "                        save_image(fake.data, img_save_path + 'Recombination/Experiment/evolution_%d_Uniform_%d.png' % (i, j), normalize=True)\n",
    "\n",
    "\n",
    "    return img_list\n",
    "\n",
    "\n",
    "img_list_experiment = experiment(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Visualize experiment:\n",
    "fig = plt.figure(figsize=(8,6))\n",
    "plt.axis(\"off\")\n",
    "ims = [[plt.imshow(np.transpose(i,(1,2,0)), animated=True)] for i in img_list_experiment]\n",
    "ani = animation.ArtistAnimation(fig, ims, interval=1000, repeat_delay=1000, blit=True)\n",
    "\n",
    "HTML(ani.to_jshtml())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Thesis",
   "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.10.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}