Molecular_WGAN-GP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "37706c9c-1ef4-4051-b17e-e54aa0664180",
   "metadata": {},
   "source": [
    "# Wasserstein GAN with Gradient Penalty for Molecular Graph images\n",
    "\n",
    "This block\n",
    "\n",
    "- imports all modules/libraries needed\n",
    "- contains a function for a learning rate scheduler (if needed)\n",
    "- reads in SMILES strings and creates a list\n",
    "- featurizes via the SmilesTo Image featurizer from Deepchem (https://github.com/deepchem/deepchem)\n",
    "- Four channel image used for featurization\n",
    "  * Atomic numbers + bonds\n",
    "  * partial charges\n",
    "  * valence\n",
    "  * hybridization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "979d0bc1-0585-4b38-903d-b64edabe0891",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\envs\\rdkitenv\\lib\\site-packages\\keras\\src\\losses.py:2976: The name tf.losses.sparse_softmax_cross_entropy is deprecated. Please use tf.compat.v1.losses.sparse_softmax_cross_entropy instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\envs\\rdkitenv\\lib\\site-packages\\tensorflow\\python\\util\\deprecation.py:588: calling function (from tensorflow.python.eager.polymorphic_function.polymorphic_function) with experimental_relax_shapes is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "experimental_relax_shapes is deprecated, use reduce_retracing instead\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Skipped loading modules with pytorch-geometric dependency, missing a dependency. No module named 'torch_geometric'\n",
      "Skipped loading modules with pytorch-geometric dependency, missing a dependency. cannot import name 'DMPNN' from 'deepchem.models.torch_models' (C:\\ProgramData\\Anaconda3\\envs\\rdkitenv\\lib\\site-packages\\deepchem\\models\\torch_models\\__init__.py)\n",
      "Skipped loading some Jax models, missing a dependency. No module named 'jax'\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of features and datapoints:  (6731, 80, 80, 4)\n",
      "featurization done with:  SmilesToImage\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import pandas as pd \n",
    "import deepchem as dc\n",
    "import time\n",
    "from rdkit import Chem\n",
    "from functools import partial\n",
    "import matplotlib.pyplot as plt\n",
    "from rdkit.Chem import AllChem, Draw\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "def exp_decay(lr0,s):\n",
    "    def exp_decay_fcn(epoch):\n",
    "        return lr0*0.1**(epoch/s)\n",
    "    return exp_decay_fcn\n",
    "\n",
    "#df = pd.read_csv(\"392-azo.csv\")\n",
    "#df = pd.read_csv(\"212-azo.csv\")\n",
    "#df = pd.read_csv(\"604-azo.csv\")\n",
    "#df = pd.read_csv(\"621-azo.csv\")\n",
    "df = pd.read_csv(\"6731-azo.csv\")\n",
    "\n",
    "Xa = [\"\"]*len(df)\n",
    "w = [\"\"]*len(df)\n",
    "i=0\n",
    "for name in df[\"SMILES\"]:\n",
    "    Xa[i]=name\n",
    "    w[i]=1.0\n",
    "    i += 1\n",
    "Xa = list(Xa)\n",
    "w=list(w)\n",
    "\n",
    "#===========================================================================================\n",
    "#featurizer\n",
    "\n",
    "featurizer=dc.feat.SmilesToImage(img_spec=\"engd\")\n",
    "featname=\"SmilesToImage\"\n",
    "\n",
    "f = featurizer.featurize(Xa)\n",
    "print(\"Number of features and datapoints: \",f.shape)\n",
    "\n",
    "#===========================================================================================\n",
    "print(\"featurization done with: \",featname)\n",
    "\n",
    "# set npp for how many points in the dataset, len(df) for whole dataset\n",
    "nnp=len(df)\n",
    "\n",
    "#set y to lambdamax\n",
    "y = df[\"Lmax\"]\n",
    "\n",
    "#set dataset and split\n",
    "\n",
    "dataset = dc.data.NumpyDataset(X=f[:nnp,:,:,:], y=y[:nnp], ids=Xa[:nnp], w=w[:nnp])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0dc88c3-17a9-48af-8032-4b0cf8d34951",
   "metadata": {},
   "source": [
    "## Define the Critic and Generator\n",
    "\n",
    "- architecture adapted from https://github.com/davidADSP/Generative_Deep_Learning_2nd_Edition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0a3fa376-fceb-4b59-8ef1-0ae20a1718c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Critic and Generator built.\n"
     ]
    }
   ],
   "source": [
    "embsize=128\n",
    "dropout_rate = 0.3\n",
    "\n",
    "#=======================================================================================================\n",
    "\n",
    "critic_input = tf.keras.layers.Input(shape=[80,80,4])\n",
    "x = tf.keras.layers.Conv2D(filters=64,kernel_size=(4,4), strides=2,padding=\"same\")(critic_input)\n",
    "x = tf.keras.layers.LeakyReLU(0.2)(x)\n",
    "x = tf.keras.layers.Dropout(dropout_rate)(x)\n",
    "x = tf.keras.layers.Conv2D(filters=128,kernel_size=(4,4), strides=2,padding=\"same\")(x)\n",
    "x = tf.keras.layers.LeakyReLU(0.2)(x)\n",
    "x = tf.keras.layers.Dropout(dropout_rate)(x)\n",
    "x = tf.keras.layers.Conv2D(filters=256,kernel_size=(4,4), strides=2,padding=\"same\")(x)\n",
    "x = tf.keras.layers.LeakyReLU(0.2)(x)\n",
    "x = tf.keras.layers.Dropout(dropout_rate)(x)\n",
    "x = tf.keras.layers.Conv2D(filters=512,kernel_size=(4,4), strides=2,padding=\"same\")(x)\n",
    "x = tf.keras.layers.LeakyReLU(0.2)(x)\n",
    "x = tf.keras.layers.Dropout(dropout_rate)(x)\n",
    "x = tf.keras.layers.Conv2D(filters=1,kernel_size=(5,5), strides=1,padding=\"valid\")(x)\n",
    "critic_output = tf.keras.layers.Flatten()(x)\n",
    "\n",
    "critic = tf.keras.models.Model(critic_input,critic_output)\n",
    "#=======================================================================================================\n",
    "\n",
    "generator_input = tf.keras.layers.Input(shape=(embsize,))\n",
    "x = tf.keras.layers.Reshape((1,1,embsize))(generator_input)\n",
    "x = tf.keras.layers.Conv2DTranspose(filters=512,kernel_size=(5,5),strides=1, padding=\"valid\", use_bias = False)(x)\n",
    "x = tf.keras.layers.BatchNormalization(momentum=0.9)(x)\n",
    "x = tf.keras.layers.LeakyReLU(0.2)(x)\n",
    "x = tf.keras.layers.Conv2DTranspose(filters=256,kernel_size=(4,4),strides=2, padding=\"same\", use_bias = False)(x)\n",
    "x = tf.keras.layers.BatchNormalization(momentum=0.9)(x)\n",
    "x = tf.keras.layers.LeakyReLU(0.2)(x)\n",
    "x = tf.keras.layers.Conv2DTranspose(filters=128,kernel_size=(4,4),strides=2, padding=\"same\", use_bias = False)(x)\n",
    "x = tf.keras.layers.BatchNormalization(momentum=0.9)(x)\n",
    "x = tf.keras.layers.LeakyReLU(0.2)(x)\n",
    "x = tf.keras.layers.Conv2DTranspose(filters=64,kernel_size=(4,4),strides=2, padding=\"same\", use_bias = False)(x)\n",
    "x = tf.keras.layers.BatchNormalization(momentum=0.9)(x)\n",
    "x = tf.keras.layers.LeakyReLU(0.2)(x)\n",
    "generator_output = tf.keras.layers.Conv2DTranspose(filters=4,kernel_size=(4,4),strides=2, padding=\"same\", \n",
    "                                                   activation = \"sigmoid\")(x)  #using activation = \"sigmoid\" here leads to blue backgrounds\n",
    "\n",
    "generator = tf.keras.models.Model(generator_input,generator_output)\n",
    "\n",
    "print(\"Critic and Generator built.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7aae5b43-eed5-4e85-b0c0-c2693688b2c5",
   "metadata": {},
   "source": [
    "## Training loop for the Wasserstein GAN with Gradient Penalty\n",
    "\n",
    "- Training loop adapted from https://github.com/davidADSP/Generative_Deep_Learning_2nd_Edition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b4be5e51-b8d8-4d00-bc94-252fbe1b4bcb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wasserstein GAN with Gradient Penalty built.\n"
     ]
    }
   ],
   "source": [
    "class WGANGP(tf.keras.models.Model):\n",
    "    def __init__(self,critic,generator,latent_dim,critic_steps, gp_weight):\n",
    "        super(WGANGP, self).__init__()\n",
    "        self.critic = critic\n",
    "        self.generator = generator\n",
    "        self.latent_dim = latent_dim\n",
    "        self.critic_steps = critic_steps\n",
    "        self.gp_weight = gp_weight\n",
    "\n",
    "    def compile(self, c_optimizer, g_optimizer):\n",
    "        super(WGANGP,self).compile()\n",
    "        self.c_optimizer = c_optimizer\n",
    "        self.g_optimizer = g_optimizer\n",
    "        self.c_wass_loss_metric = tf.keras.metrics.Mean(name=\"c_wass_loss\")\n",
    "        self.c_gp_metric = tf.keras.metrics.Mean(name=\"c_gp\")\n",
    "        self.c_loss_metric = tf.keras.metrics.Mean(name=\"c_loss\")\n",
    "        self.g_loss_metric = tf.keras.metrics.Mean(name=\"g_loss\")\n",
    "\n",
    "    @property\n",
    "    def metrics(self):\n",
    "        return [ self.c_loss_metric, self.c_wass_loss_metric,\n",
    "                self.c_gp_metric, self.g_loss_metric]\n",
    "\n",
    "    def gradient_penalty(self,batch_size, real_images, fake_images):\n",
    "        alpha = tf.random.normal([batch_size,1,1,1],0.0, 1.0)\n",
    "        diff = fake_images - real_images\n",
    "        interpolated = real_images + alpha * diff\n",
    "\n",
    "        with tf.GradientTape() as gp_tape:\n",
    "            gp_tape.watch(interpolated)\n",
    "            pred = self.critic(interpolated, training = True)\n",
    "\n",
    "        grads = gp_tape.gradient(pred, [interpolated])[0]\n",
    "        norm = tf.sqrt(tf.reduce_sum(tf.square(grads), axis = [1,2,3]))\n",
    "        gp = tf.reduce_mean((norm - 1.0) ** 2)\n",
    "        return gp\n",
    "    \n",
    "    def train_step(self, real_images):\n",
    "        batch_size = tf.shape(real_images)[0]\n",
    "\n",
    "        for i in range(self.critic_steps):\n",
    "            random_latent_vectors = tf.random.normal(shape=(batch_size,self.latent_dim))\n",
    "\n",
    "            with tf.GradientTape() as tape:\n",
    "                generated_images = self.generator(random_latent_vectors, training = True)\n",
    "                real_predictions = self.critic(real_images, training = True)\n",
    "                fake_predictions = self.critic(generated_images, training = True)\n",
    "\n",
    "                c_wass_loss = tf.reduce_mean(fake_predictions) - tf.reduce_mean(real_predictions)\n",
    "                c_gp = self.gradient_penalty(batch_size, real_images, generated_images)\n",
    "                c_loss = c_wass_loss + c_gp * self.gp_weight\n",
    "\n",
    "            c_gradient = tape.gradient(c_loss, self.critic.trainable_variables)\n",
    "            self.c_optimizer.apply_gradients(zip(c_gradient,self.critic.trainable_variables))\n",
    "\n",
    "        random_latent_vectors = tf.random.normal(shape=(batch_size,self.latent_dim))\n",
    "\n",
    "        with tf.GradientTape() as tape:\n",
    "            generated_images = self.generator(random_latent_vectors, training = True)\n",
    "            fake_predictions = self.critic(generated_images, training = True)\n",
    "            g_loss = -tf.reduce_mean(fake_predictions)\n",
    "            \n",
    "        gen_gradient = tape.gradient(g_loss, self.generator.trainable_variables)\n",
    "        self.g_optimizer.apply_gradients(zip(gen_gradient, self.generator.trainable_variables))\n",
    "\n",
    "        self.c_loss_metric.update_state(c_loss)\n",
    "        self.g_loss_metric.update_state(g_loss)\n",
    "        self.c_wass_loss_metric.update_state(c_wass_loss)\n",
    "        self.c_gp_metric.update_state(c_gp)\n",
    "\n",
    "        return {m.name: m.result() for m in self.metrics}\n",
    "\n",
    "wgangp = WGANGP(critic = critic, generator = generator, latent_dim = embsize,\n",
    "               critic_steps = 3, gp_weight = 10.0)\n",
    "\n",
    "print(\"Wasserstein GAN with Gradient Penalty built.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0caf3e80-5186-4be3-b1be-b8cc4f80e35a",
   "metadata": {},
   "source": [
    "## Train the WGAN-GP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "853a3ba0-895f-4768-81e9-a5c8d1ba3205",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/25\n",
      "106/106 [==============================] - 419s 4s/step - c_loss: -230.1199 - c_wass_loss: -397.1971 - c_gp: 16.7077 - g_loss: 389.5749\n",
      "Epoch 2/25\n",
      "106/106 [==============================] - 424s 4s/step - c_loss: -127.3054 - c_wass_loss: -208.7862 - c_gp: 8.1481 - g_loss: 169.1725\n",
      "Epoch 3/25\n",
      "106/106 [==============================] - 427s 4s/step - c_loss: -85.9189 - c_wass_loss: -133.7031 - c_gp: 4.7784 - g_loss: 76.1599\n",
      "Epoch 4/25\n",
      "106/106 [==============================] - 437s 4s/step - c_loss: -76.1074 - c_wass_loss: -116.5217 - c_gp: 4.0414 - g_loss: 46.4453\n",
      "Epoch 5/25\n",
      "106/106 [==============================] - 441s 4s/step - c_loss: -72.9403 - c_wass_loss: -110.9859 - c_gp: 3.8046 - g_loss: 40.9871\n",
      "Epoch 6/25\n",
      "106/106 [==============================] - 428s 4s/step - c_loss: -70.5768 - c_wass_loss: -107.9426 - c_gp: 3.7366 - g_loss: 35.9796\n",
      "Epoch 7/25\n",
      "106/106 [==============================] - 432s 4s/step - c_loss: -67.4326 - c_wass_loss: -102.7342 - c_gp: 3.5302 - g_loss: 28.7310\n",
      "Epoch 8/25\n",
      "106/106 [==============================] - 444s 4s/step - c_loss: -64.5504 - c_wass_loss: -96.9790 - c_gp: 3.2429 - g_loss: 20.4331\n",
      "Epoch 9/25\n",
      "106/106 [==============================] - 420s 4s/step - c_loss: -62.9584 - c_wass_loss: -94.6631 - c_gp: 3.1705 - g_loss: 12.5472\n",
      "Epoch 10/25\n",
      "106/106 [==============================] - 443s 4s/step - c_loss: -62.6521 - c_wass_loss: -94.4170 - c_gp: 3.1765 - g_loss: 8.3590\n",
      "Epoch 11/25\n",
      "106/106 [==============================] - 431s 4s/step - c_loss: -61.1886 - c_wass_loss: -92.2937 - c_gp: 3.1105 - g_loss: 6.2411\n",
      "Epoch 12/25\n",
      "106/106 [==============================] - 428s 4s/step - c_loss: -61.0801 - c_wass_loss: -91.9814 - c_gp: 3.0901 - g_loss: 5.6828\n",
      "Epoch 13/25\n",
      "106/106 [==============================] - 422s 4s/step - c_loss: -62.1667 - c_wass_loss: -92.1680 - c_gp: 3.0001 - g_loss: 15.6257\n",
      "Epoch 14/25\n",
      "106/106 [==============================] - 390s 4s/step - c_loss: -61.3867 - c_wass_loss: -91.3928 - c_gp: 3.0006 - g_loss: 25.7771\n",
      "Epoch 15/25\n",
      "106/106 [==============================] - 399s 4s/step - c_loss: -60.4505 - c_wass_loss: -90.8106 - c_gp: 3.0360 - g_loss: 31.6030\n",
      "Epoch 16/25\n",
      "106/106 [==============================] - 431s 4s/step - c_loss: -60.9143 - c_wass_loss: -91.2298 - c_gp: 3.0316 - g_loss: 46.7269\n",
      "Epoch 17/25\n",
      "106/106 [==============================] - 405s 4s/step - c_loss: -59.8127 - c_wass_loss: -90.1796 - c_gp: 3.0367 - g_loss: 47.7389\n",
      "Epoch 18/25\n",
      "106/106 [==============================] - 401s 4s/step - c_loss: -58.7839 - c_wass_loss: -88.0198 - c_gp: 2.9236 - g_loss: 55.7682\n",
      "Epoch 19/25\n",
      "106/106 [==============================] - 404s 4s/step - c_loss: -58.4129 - c_wass_loss: -87.4568 - c_gp: 2.9044 - g_loss: 64.8428\n",
      "Epoch 20/25\n",
      "106/106 [==============================] - 416s 4s/step - c_loss: -59.8958 - c_wass_loss: -88.6367 - c_gp: 2.8741 - g_loss: 66.1153\n",
      "Epoch 21/25\n",
      "106/106 [==============================] - 417s 4s/step - c_loss: -58.3240 - c_wass_loss: -87.4971 - c_gp: 2.9173 - g_loss: 56.5318\n",
      "Epoch 22/25\n",
      "106/106 [==============================] - 408s 4s/step - c_loss: -58.0008 - c_wass_loss: -86.7388 - c_gp: 2.8738 - g_loss: 69.7691\n",
      "Epoch 23/25\n",
      "106/106 [==============================] - 392s 4s/step - c_loss: -57.4517 - c_wass_loss: -85.3517 - c_gp: 2.7900 - g_loss: 84.5995\n",
      "Epoch 24/25\n",
      "106/106 [==============================] - 424s 4s/step - c_loss: -57.5825 - c_wass_loss: -85.5343 - c_gp: 2.7952 - g_loss: 86.9431\n",
      "Epoch 25/25\n",
      "106/106 [==============================] - 578s 5s/step - c_loss: -58.6257 - c_wass_loss: -86.3704 - c_gp: 2.7745 - g_loss: 119.5053\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.src.callbacks.History at 0x1dd771a8be0>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wgangp.compile(c_optimizer = tf.keras.optimizers.Adam(learning_rate = 0.0001, beta_1 = 0.5, beta_2 = 0.999),\n",
    "               g_optimizer = tf.keras.optimizers.Adam(learning_rate = 0.0001, beta_1 = 0.5, beta_2 = 0.999))\n",
    "\n",
    "wgangp.fit(dataset.X, epochs = 25, batch_size = 64)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40fa585e-c87d-4f2d-ad70-31c6fab66be1",
   "metadata": {},
   "source": [
    "## Plot generated images\n",
    "\n",
    "- use the generator to make a couple of images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "67b11efd-d5fa-4ebf-b03b-94ce46795f2e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 59ms/step\n",
      "(2, 80, 80, 4)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#load a model\n",
    "#decoder = tf.keras.models.load_model(\"6731_1April_test_Wassgenerator\")\n",
    "\n",
    "z_gen = np.random.normal(size=(2,embsize))\n",
    "\n",
    "recons_embed = generator.predict(z_gen)\n",
    "print(recons_embed.shape)\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "from scipy import ndimage\n",
    "\n",
    "cmap=\"tab20c\"\n",
    "\n",
    "def new_images(image,channel):\n",
    "    recons = image[:,:,channel] #last number cycles through channels 0-3\n",
    "    rot = ndimage.rotate(recons, 0)\n",
    "    rot  = rot[20:60, 20:60]\n",
    "    return rot\n",
    "\n",
    "newimages=[]\n",
    "newimages2=[]\n",
    "for i in range(4):\n",
    "    new1 = new_images(image=recons_embed[0],channel=i)\n",
    "    newimages.append(new1)\n",
    "    new1 = new_images(image=recons_embed[1],channel=i)\n",
    "    newimages2.append(new1)\n",
    "    \n",
    "#can insert scaling code here\n",
    "\n",
    "fig, arrax = plt.subplots(2, 4, figsize=(12,6))\n",
    "for i in range(4):\n",
    "    arrax[0,i].imshow(newimages[i],cmap=cmap)\n",
    "    arrax[1,i].imshow(newimages2[i],cmap=cmap)\n",
    "    arrax[0,i].axis(\"off\")\n",
    "    arrax[1,i].axis(\"off\")\n",
    "arrax[0,0].set_title(\"Generated Images (channels 1-4)\")\n",
    "arrax[1,0].set_title(\"Generated Images (channels 1-4)\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2a718f7-d9a1-4df2-bda2-b8c810428f2e",
   "metadata": {},
   "source": [
    "## Save WGAN-GP components"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "7b7d6ca5-7484-4f78-a6c0-0f3ebd834859",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: 6731_1April_test_critic\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: 6731_1April_test_critic\\assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Critic model saved.\n",
      "WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: 6731_1April_test_Wassgenerator\\assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: 6731_1April_test_Wassgenerator\\assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generator model saved.\n"
     ]
    }
   ],
   "source": [
    "critic.save(\"6731_1April_test_critic\",save_format=\"tf\")\n",
    "print(\"Critic model saved.\")\n",
    "\n",
    "generator.save(\"6731_1April_test_Wassgenerator\",save_format=\"tf\")\n",
    "print(\"Generator model saved.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96afa96f-6948-4c9a-add7-225ff943c148",
   "metadata": {},
   "source": [
    "## Load and restart training on the Wasserstein GAN with Gradient Penalty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8c5f08b6-39cd-4671-a73f-fb30ac584c73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 31/40\n",
      "106/106 [==============================] - 448s 4s/step - c_loss: -54.6430 - c_wass_loss: -82.1224 - c_gp: 2.7479 - g_loss: 74.4574\n",
      "Epoch 32/40\n",
      "106/106 [==============================] - 460s 4s/step - c_loss: -53.7754 - c_wass_loss: -80.4547 - c_gp: 2.6679 - g_loss: 80.4183\n",
      "Epoch 33/40\n",
      "106/106 [==============================] - 444s 4s/step - c_loss: -55.4084 - c_wass_loss: -81.7291 - c_gp: 2.6321 - g_loss: 93.0261\n",
      "Epoch 34/40\n",
      "106/106 [==============================] - 448s 4s/step - c_loss: -54.9578 - c_wass_loss: -81.5332 - c_gp: 2.6575 - g_loss: 102.9184\n",
      "Epoch 35/40\n",
      "106/106 [==============================] - 456s 4s/step - c_loss: -55.8520 - c_wass_loss: -82.4011 - c_gp: 2.6549 - g_loss: 126.5514\n",
      "Epoch 36/40\n",
      "106/106 [==============================] - 444s 4s/step - c_loss: -54.2432 - c_wass_loss: -80.5514 - c_gp: 2.6308 - g_loss: 155.4334\n",
      "Epoch 37/40\n",
      "106/106 [==============================] - 444s 4s/step - c_loss: -53.6977 - c_wass_loss: -79.0904 - c_gp: 2.5393 - g_loss: 183.7347\n",
      "Epoch 38/40\n",
      "106/106 [==============================] - 446s 4s/step - c_loss: -53.7825 - c_wass_loss: -79.3818 - c_gp: 2.5599 - g_loss: 189.3720\n",
      "Epoch 39/40\n",
      "106/106 [==============================] - 456s 4s/step - c_loss: -54.3345 - c_wass_loss: -80.6996 - c_gp: 2.6365 - g_loss: 243.0146\n",
      "Epoch 40/40\n",
      "106/106 [==============================] - 455s 4s/step - c_loss: -52.8787 - c_wass_loss: -78.2355 - c_gp: 2.5357 - g_loss: 242.6320\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.src.callbacks.History at 0x1dd752cea70>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#critic = tf.keras.models.load_model(\"6731_1April_test_critic\")\n",
    "#generator = tf.keras.models.load_model(\"6731_1April_test_Wassgenerator\")\n",
    "epcs = 30\n",
    "\n",
    "wgangp.compile(c_optimizer = tf.keras.optimizers.Adam(learning_rate = 0.0001, beta_1 = 0.5, beta_2 = 0.999),\n",
    "               g_optimizer = tf.keras.optimizers.Adam(learning_rate = 0.0001, beta_1 = 0.5, beta_2 = 0.999))\n",
    "\n",
    "wgangp.fit(dataset.X, epochs = epcs+10, batch_size = 64, initial_epoch = epcs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5e80d75-0a3a-4ddf-adc3-f8f1e94088c6",
   "metadata": {},
   "source": [
    "## Code for scaling images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68654c36-66de-49fe-a5dc-b54b51b01c13",
   "metadata": {},
   "outputs": [],
   "source": [
    "#scaling for images\n",
    "biggest, smallest = 0.0, 6000.0\n",
    "tmp=np.empty(2)\n",
    "for i in range(4):\n",
    "    tmp[0] = newimages[i].max()\n",
    "    tmp[1] = oldimages[i].max()\n",
    "    tmps = tmp.max()\n",
    "    if tmps > biggest:\n",
    "        biggest = tmps\n",
    "    tmp[0] = newimages[i].min()\n",
    "    tmp[1] = oldimages[i].min()\n",
    "    tmps = tmp.min()\n",
    "    if tmps < smallest:\n",
    "        smallest = tmps\n",
    "scaled_newimages = ((newimages - smallest) * (1/(biggest-smallest)) * 255).astype('uint8')\n",
    "scaled_oldimages = ((oldimages - smallest) * (1/(biggest-smallest)) * 255).astype('uint8')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}