GA-mnist.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%load_ext autoreload"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Genetic algorithm for hyperparameter optimization on the mnist dataset.\n",
    "Credits: https://github.com/guibacellar/OpenAi/blob/master/CartPole-GA.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-07-03 11:05:27.842279: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  SSE4.1 SSE4.2 AVX AVX2 AVX512F AVX512_VNNI FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-07-03 11:05:27.927664: I tensorflow/core/util/port.cc:104] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import random\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import time\n",
    "from keras.models import Sequential\n",
    "from keras.datasets import mnist\n",
    "from keras.layers import Dense, Dropout, InputLayer\n",
    "from keras import backend as K\n",
    "from keras.utils import to_categorical\n",
    "from matplotlib import pyplot\n",
    "import ipywidgets\n",
    "\n",
    "# pyplot.style.use(['dark_background'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# local imports\n",
    "from gahyparopt.gahyperopt import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Define Hyperparameters for NN\n",
    "HIDDEN_LAYER_COUNT = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "HIDDEN_LAYER_NEURONS = [8, 16, 24, 32, 64, 128, 256, 512]\n",
    "HIDDEN_LAYER_RATE = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n",
    "HIDDEN_LAYER_ACTIVATIONS = ['relu', 'tanh', 'sigmoid']\n",
    "HIDDEN_LAYER_TYPE = ['dense', 'dropout']\n",
    "MODEL_OPTIMIZER = ['rmsprop', 'adams', 'sgd']\n",
    "\n",
    "# Define Genetic Algorithm Parameters\n",
    "MAX_GENERATIONS = 100  # Max Number of Generations to Apply the Genetic Algorithm\n",
    "POPULATION_SIZE = 8  # Max Number of Individuals in Each Population\n",
    "BEST_CANDIDATES_COUNT = 2  # Number of Best Candidates to Use\n",
    "RANDOM_CANDIDATES_COUNT = 1  # Number of Random Candidates (From Entire Population of Generation) to Next Population\n",
    "OPTIMIZER_MUTATION_PROBABILITY = 0.3  # 10% of Probability to Apply Mutation on Optimizer Parameter\n",
    "HIDDEN_LAYER_MUTATION_PROBABILITY = 0.4  # 10% of Probability to Apply Mutation on Hidden Layer Quantity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "ga = GADriver(layer_counts=HIDDEN_LAYER_COUNT,\n",
    "                     no_neurons=HIDDEN_LAYER_NEURONS,\n",
    "                     rates=HIDDEN_LAYER_RATE,\n",
    "                     activations=HIDDEN_LAYER_ACTIVATIONS,\n",
    "                     layer_types=HIDDEN_LAYER_TYPE,\n",
    "                     optimizers=MODEL_OPTIMIZER,\n",
    "                     population_size=POPULATION_SIZE,\n",
    "                     best_candidates_count=BEST_CANDIDATES_COUNT,\n",
    "                     random_candidates_count=RANDOM_CANDIDATES_COUNT,\n",
    "                     optimizer_mutation_probability=OPTIMIZER_MUTATION_PROBABILITY,\n",
    "                     layer_mutation_probability=HIDDEN_LAYER_MUTATION_PROBABILITY,\n",
    "                    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"7\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Get test and training data.\n",
    "data = load_mnist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "16b07e4de02d4b618eacf3acaf0ce7bc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=0, description='i', max=39999, step=100), Output()), _dom_classes=('widg…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@ipywidgets.interact(i=ipywidgets.IntSlider(min=0, max=40000-1, step=100, value=0))\n",
    "def plot_mnist_figure(i):\n",
    "    print(data['y_train'][i])\n",
    "    pyplot.imshow(data['x_train'][i].reshape(28,28), cmap='bone_r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def generate_reference_ml(data):\n",
    "    \"\"\"\n",
    "    Train and Generate NN Model based on https://github.com/fchollet/deep-learning-with-python-notebooks/blobs/master/2.1-a-first-look-at-a-neural-netword.ipynb'\n",
    "    :param df: Dataframe to Training Process\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    print(\"[+] Training Original NN Model: \", end='')\n",
    "    run_start = time.time()\n",
    "\n",
    "    # Define Neural model Topology\n",
    "    model = Sequential()\n",
    "    model.add(Dense(512, activation='relu', input_shape=(28 * 28,)))\n",
    "    model.add(Dense(10, activation='softmax'))\n",
    "\n",
    "    # Compile Neural model\n",
    "    model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])\n",
    "    model.summary()\n",
    "\n",
    "    # Fit Model with Data\n",
    "    x_train, y_train, x_val, y_val = data.values()\n",
    "    training = model.fit(x_train, y_train,\n",
    "        epochs=20,\n",
    "        batch_size=128,\n",
    "        steps_per_epoch=300,\n",
    "        verbose=1,\n",
    "        validation_data=(x_val, y_val),\n",
    "    )\n",
    "\n",
    "    run_stop = time.time()\n",
    "    print(f\"Done > Takes {run_stop-run_start} sec\")\n",
    "\n",
    "    return model, training\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[+] Training Original NN Model: "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-07-03 11:05:30.365687: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  SSE4.1 SSE4.2 AVX AVX2 AVX512F AVX512_VNNI FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-07-03 11:05:30.913172: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1613] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 9383 MB memory:  -> device: 0, name: NVIDIA GeForce RTX 2080 Ti, pci bus id: 0000:b2:00.0, compute capability: 7.5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " dense (Dense)               (None, 512)               401920    \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 10)                5130      \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 407,050\n",
      "Trainable params: 407,050\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "Epoch 1/20\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-07-03 11:05:32.491163: I tensorflow/compiler/xla/service/service.cc:173] XLA service 0x7fb14401bea0 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n",
      "2023-07-03 11:05:32.491223: I tensorflow/compiler/xla/service/service.cc:181]   StreamExecutor device (0): NVIDIA GeForce RTX 2080 Ti, Compute Capability 7.5\n",
      "2023-07-03 11:05:32.505475: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:268] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n",
      "2023-07-03 11:05:32.621049: I tensorflow/tsl/platform/default/subprocess.cc:304] Start cannot spawn child process: No such file or directory\n",
      "2023-07-03 11:05:32.672885: I tensorflow/compiler/jit/xla_compilation_cache.cc:477] Compiled cluster using XLA!  This line is logged at most once for the lifetime of the process.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 4s 8ms/step - loss: 0.3254 - accuracy: 0.9062 - val_loss: 0.1791 - val_accuracy: 0.9487\n",
      "Epoch 2/20\n",
      "300/300 [==============================] - 2s 8ms/step - loss: 0.1349 - accuracy: 0.9610 - val_loss: 0.1323 - val_accuracy: 0.9600\n",
      "Epoch 3/20\n",
      "300/300 [==============================] - 2s 7ms/step - loss: 0.0910 - accuracy: 0.9732 - val_loss: 0.1059 - val_accuracy: 0.9692\n",
      "Epoch 4/20\n",
      "300/300 [==============================] - 2s 7ms/step - loss: 0.0663 - accuracy: 0.9810 - val_loss: 0.0949 - val_accuracy: 0.9714\n",
      "Epoch 5/20\n",
      "300/300 [==============================] - 2s 7ms/step - loss: 0.0480 - accuracy: 0.9860 - val_loss: 0.0898 - val_accuracy: 0.9735\n",
      "Epoch 6/20\n",
      "300/300 [==============================] - 2s 7ms/step - loss: 0.0353 - accuracy: 0.9900 - val_loss: 0.0901 - val_accuracy: 0.9749\n",
      "Epoch 7/20\n",
      "300/300 [==============================] - 2s 7ms/step - loss: 0.0276 - accuracy: 0.9924 - val_loss: 0.0904 - val_accuracy: 0.9758\n",
      "Epoch 8/20\n",
      "300/300 [==============================] - 2s 7ms/step - loss: 0.0217 - accuracy: 0.9942 - val_loss: 0.0887 - val_accuracy: 0.9758\n",
      "Epoch 9/20\n",
      "300/300 [==============================] - 2s 7ms/step - loss: 0.0160 - accuracy: 0.9960 - val_loss: 0.0949 - val_accuracy: 0.9766\n",
      "Epoch 10/20\n",
      "300/300 [==============================] - 2s 8ms/step - loss: 0.0121 - accuracy: 0.9972 - val_loss: 0.0862 - val_accuracy: 0.9768\n",
      "Epoch 11/20\n",
      "300/300 [==============================] - 2s 7ms/step - loss: 0.0095 - accuracy: 0.9980 - val_loss: 0.0877 - val_accuracy: 0.9767\n",
      "Epoch 12/20\n",
      "300/300 [==============================] - 2s 7ms/step - loss: 0.0070 - accuracy: 0.9986 - val_loss: 0.0891 - val_accuracy: 0.9780\n",
      "Epoch 13/20\n",
      "300/300 [==============================] - 2s 7ms/step - loss: 0.0044 - accuracy: 0.9993 - val_loss: 0.0909 - val_accuracy: 0.9771\n",
      "Epoch 14/20\n",
      "300/300 [==============================] - 2s 8ms/step - loss: 0.0034 - accuracy: 0.9995 - val_loss: 0.0918 - val_accuracy: 0.9772\n",
      "Epoch 15/20\n",
      "300/300 [==============================] - 2s 7ms/step - loss: 0.0019 - accuracy: 0.9999 - val_loss: 0.0917 - val_accuracy: 0.9783\n",
      "Epoch 16/20\n",
      "300/300 [==============================] - 2s 7ms/step - loss: 0.0014 - accuracy: 0.9999 - val_loss: 0.0938 - val_accuracy: 0.9783\n",
      "Epoch 17/20\n",
      "300/300 [==============================] - 2s 7ms/step - loss: 0.0011 - accuracy: 1.0000 - val_loss: 0.0952 - val_accuracy: 0.9787\n",
      "Epoch 18/20\n",
      "300/300 [==============================] - 2s 8ms/step - loss: 8.1556e-04 - accuracy: 0.9999 - val_loss: 0.0956 - val_accuracy: 0.9786\n",
      "Epoch 19/20\n",
      "300/300 [==============================] - 2s 8ms/step - loss: 6.6673e-04 - accuracy: 1.0000 - val_loss: 0.0965 - val_accuracy: 0.9788\n",
      "Epoch 20/20\n",
      "300/300 [==============================] - 2s 7ms/step - loss: 5.5647e-04 - accuracy: 1.0000 - val_loss: 0.0975 - val_accuracy: 0.9786\n",
      "Done > Takes 47.49248504638672 sec\n"
     ]
    }
   ],
   "source": [
    "# Creates a Reference NN Model based on \n",
    "ml_model, training = generate_reference_ml(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from tensorflow.keras.utils import plot_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot = plot_model(ml_model, show_shapes=True, )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "IPython.core.display.Image"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(plot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(plot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f58eac8e100>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "history = pd.DataFrame(training.history)\n",
    "\n",
    "fig, ax = pyplot.subplots(2,1)\n",
    "history['loss'].plot(ax=ax[0], style=\"o\",label='loss')\n",
    "history['val_loss'].plot(ax=ax[0], style=\"o\",label='val loss')\n",
    "ax[0].legend()\n",
    "history['accuracy'].plot(ax=ax[1], style=\"o\",label='acc')\n",
    "history['val_accuracy'].plot(ax=ax[1], style=\"o\",label='val acc')\n",
    "ax[1].legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "625/625 [==============================] - 2s 2ms/step - loss: 0.1412 - accuracy: 0.9759\n",
      "\tAccuracy:0.9758999943733215 | Loss:0.14124155044555664 |\n"
     ]
    }
   ],
   "source": [
    "# Play Games with Reference NN Model\n",
    "print(\"[+] Evaluate reference model \\t>\", end='', flush=True)\n",
    "loss, accuracy  = evaluate_model(ml_model=ml_model, x = data['x_val'], y=data['y_val'])\n",
    "print(f\"\\tAccuracy:{accuracy} | Loss:{loss} |\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "********** Genetic Algorithm **********\n",
      "[+] Creating Initial NN Model Population Randomly: Done > Takes 0.0002484321594238281 sec\n"
     ]
    }
   ],
   "source": [
    "# >>>>>> Genetic Algorithm Section <<<<<<\n",
    "print(\"\\n********** Genetic Algorithm **********\")\n",
    "population = ga.generate_first_population_randomly()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(population)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[+] Generation 1 of 100\n",
      "\tTraining Models:\n",
      "\t\tGenerating model for individual 0\n",
      "\t\tGenerating model for individual 1\n",
      "\t\tGenerating model for individual 2\n",
      "\t\tGenerating model for individual 3\n",
      "\t\tGenerating model for individual 4\n",
      "Done > Takes 68.8868579864502 sec\n",
      "\tEvaluating Population: \n",
      "\t\tIndividual 0\n",
      "625/625 [==============================] - 1s 2ms/step - loss: 0.2013 - accuracy: 0.9431\n",
      "\t\tIndividual 1\n",
      "625/625 [==============================] - 2s 3ms/step - loss: 1.0833 - accuracy: 0.6234\n",
      "\t\tIndividual 2\n",
      "625/625 [==============================] - 2s 3ms/step - loss: 1.7675 - accuracy: 0.5201\n",
      "\t\tIndividual 3\n",
      "625/625 [==============================] - 1s 2ms/step - loss: 2.3024 - accuracy: 0.1000\n",
      "\t\tIndividual 4\n",
      "625/625 [==============================] - 1s 2ms/step - loss: 2.3016 - accuracy: 0.1089\n",
      "Done > Takes 7.984793424606323 sec\n",
      "[+] Generation 2 of 100\n",
      "\tTraining Models:\n",
      "\t\tGenerating model for individual 0\n",
      "\t\tGenerating model for individual 1\n",
      "\t\tGenerating model for individual 2\n",
      "\t\tGenerating model for individual 3\n",
      "\t\tGenerating model for individual 4\n",
      "Done > Takes 66.80543684959412 sec\n",
      "\tEvaluating Population: \n",
      "\t\tIndividual 0\n",
      "625/625 [==============================] - 1s 2ms/step - loss: 0.2128 - accuracy: 0.9378\n",
      "\t\tIndividual 1\n",
      "625/625 [==============================] - 2s 3ms/step - loss: 1.0338 - accuracy: 0.6032\n",
      "\t\tIndividual 2\n",
      "625/625 [==============================] - 1s 2ms/step - loss: 2.3026 - accuracy: 0.1089\n",
      "\t\tIndividual 3\n",
      "625/625 [==============================] - 2s 2ms/step - loss: 0.3283 - accuracy: 0.9143\n",
      "\t\tIndividual 4\n",
      "625/625 [==============================] - 1s 2ms/step - loss: 2.2754 - accuracy: 0.1938\n",
      "Done > Takes 8.04120945930481 sec\n",
      "[+] Generation 3 of 100\n",
      "\tTraining Models:\n",
      "\t\tGenerating model for individual 0\n",
      "\t\tGenerating model for individual 1\n",
      "\t\tGenerating model for individual 2\n",
      "\t\tGenerating model for individual 3\n",
      "\t\tGenerating model for individual 4\n",
      "Done > Takes 66.9724645614624 sec\n",
      "\tEvaluating Population: \n",
      "\t\tIndividual 0\n",
      "625/625 [==============================] - 2s 2ms/step - loss: 0.2379 - accuracy: 0.9309\n",
      "\t\tIndividual 1\n",
      "625/625 [==============================] - 2s 3ms/step - loss: 0.2417 - accuracy: 0.9392\n",
      "\t\tIndividual 2\n",
      "625/625 [==============================] - 1s 2ms/step - loss: 0.2379 - accuracy: 0.9309\n",
      "\t\tIndividual 3\n",
      "625/625 [==============================] - 2s 3ms/step - loss: 0.1978 - accuracy: 0.9417\n",
      "\t\tIndividual 4\n",
      "625/625 [==============================] - 2s 2ms/step - loss: 0.4338 - accuracy: 0.8960\n",
      "Done > Takes 8.36791443824768 sec\n",
      "[+] Generation 4 of 100\n",
      "\tTraining Models:\n",
      "\t\tGenerating model for individual 0\n",
      "\t\tGenerating model for individual 1\n",
      "\t\tGenerating model for individual 2\n",
      "\t\tGenerating model for individual 3\n",
      "\t\tGenerating model for individual 4\n",
      "Done > Takes 69.73271679878235 sec\n",
      "\tEvaluating Population: \n",
      "\t\tIndividual 0\n",
      "625/625 [==============================] - 2s 3ms/step - loss: 0.3021 - accuracy: 0.9049\n",
      "\t\tIndividual 1\n",
      "625/625 [==============================] - 2s 3ms/step - loss: 0.2625 - accuracy: 0.9366\n",
      "\t\tIndividual 2\n",
      "625/625 [==============================] - 2s 2ms/step - loss: 0.2625 - accuracy: 0.9366\n",
      "\t\tIndividual 3\n",
      "625/625 [==============================] - 2s 2ms/step - loss: 0.2688 - accuracy: 0.9324\n",
      "\t\tIndividual 4\n",
      "625/625 [==============================] - 2s 3ms/step - loss: 0.2922 - accuracy: 0.9215\n",
      "Done > Takes 8.444944143295288 sec\n",
      "[+] Generation 5 of 100\n",
      "\tTraining Models:\n",
      "\t\tGenerating model for individual 0\n",
      "\t\tGenerating model for individual 1\n",
      "\t\tGenerating model for individual 2\n",
      "\t\tGenerating model for individual 3\n",
      "\t\tGenerating model for individual 4\n",
      "Done > Takes 68.65926384925842 sec\n",
      "\tEvaluating Population: \n",
      "\t\tIndividual 0\n",
      "625/625 [==============================] - 2s 2ms/step - loss: 0.3046 - accuracy: 0.9173\n",
      "\t\tIndividual 1\n",
      "625/625 [==============================] - 2s 3ms/step - loss: 0.3046 - accuracy: 0.9173\n",
      "\t\tIndividual 2\n",
      "625/625 [==============================] - 2s 3ms/step - loss: 0.2863 - accuracy: 0.9218\n",
      "\t\tIndividual 3\n",
      "625/625 [==============================] - 2s 3ms/step - loss: 0.3006 - accuracy: 0.9183\n",
      "\t\tIndividual 4\n",
      "625/625 [==============================] - 2s 3ms/step - loss: 0.2469 - accuracy: 0.9360\n",
      "Done > Takes 8.527219295501709 sec\n",
      "[+] Generation 6 of 100\n",
      "\tTraining Models:\n",
      "\t\tGenerating model for individual 0\n",
      "\t\tGenerating model for individual 1\n",
      "\t\tGenerating model for individual 2\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-14-5f628fba2b0e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     11\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mindividual\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpopulation\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"\\t\\tGenerating model for individual {i}\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mend\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'\\n'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mflush\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m         \u001b[0mga\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenerate_model_from_chromosome\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindividual\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m     \u001b[0mtraining_stop\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/Repositories/gahyparopt/gahyperopt.py\u001b[0m in \u001b[0;36mgenerate_model_from_chromosome\u001b[0;34m(self, data, chromosome)\u001b[0m\n\u001b[1;32m    122\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    123\u001b[0m         \u001b[0;31m# Fit Model with Data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 124\u001b[0;31m         m_model.fit(\n\u001b[0m\u001b[1;32m    125\u001b[0m             \u001b[0mx_train\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    126\u001b[0m             \u001b[0my_train\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.conda/envs/pydl-tf2.2/lib/python3.8/site-packages/tensorflow/python/keras/engine/training.py\u001b[0m in \u001b[0;36m_method_wrapper\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m     64\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m_method_wrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     65\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_in_multi_worker_mode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 66\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     67\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     68\u001b[0m     \u001b[0;31m# Running inside `run_distribute_coordinator` already.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.conda/envs/pydl-tf2.2/lib/python3.8/site-packages/tensorflow/python/keras/engine/training.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[1;32m    860\u001b[0m           val_x, val_y, val_sample_weight = (\n\u001b[1;32m    861\u001b[0m               data_adapter.unpack_x_y_sample_weight(validation_data))\n\u001b[0;32m--> 862\u001b[0;31m           val_logs = self.evaluate(\n\u001b[0m\u001b[1;32m    863\u001b[0m               \u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mval_x\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    864\u001b[0m               \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mval_y\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.conda/envs/pydl-tf2.2/lib/python3.8/site-packages/tensorflow/python/keras/engine/training.py\u001b[0m in \u001b[0;36m_method_wrapper\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m     64\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m_method_wrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     65\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_in_multi_worker_mode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 66\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     67\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     68\u001b[0m     \u001b[0;31m# Running inside `run_distribute_coordinator` already.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.conda/envs/pydl-tf2.2/lib/python3.8/site-packages/tensorflow/python/keras/engine/training.py\u001b[0m in \u001b[0;36mevaluate\u001b[0;34m(self, x, y, batch_size, verbose, sample_weight, steps, callbacks, max_queue_size, workers, use_multiprocessing, return_dict)\u001b[0m\n\u001b[1;32m   1079\u001b[0m                 step_num=step):\n\u001b[1;32m   1080\u001b[0m               \u001b[0mcallbacks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_test_batch_begin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1081\u001b[0;31m               \u001b[0mtmp_logs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtest_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1082\u001b[0m               \u001b[0;31m# Catch OutOfRangeError for Datasets of unknown size.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1083\u001b[0m               \u001b[0;31m# This blocks until the batch has finished executing.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.conda/envs/pydl-tf2.2/lib/python3.8/site-packages/tensorflow/python/eager/def_function.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    578\u001b[0m         \u001b[0mxla_context\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mExit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    579\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 580\u001b[0;31m       \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    581\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    582\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mtracing_count\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_tracing_count\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.conda/envs/pydl-tf2.2/lib/python3.8/site-packages/tensorflow/python/eager/def_function.py\u001b[0m in \u001b[0;36m_call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    616\u001b[0m       \u001b[0;31m# In this case we have not created variables on the first call. So we can\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    617\u001b[0m       \u001b[0;31m# run the first trace but we should fail if variables are created.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 618\u001b[0;31m       \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_stateful_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    619\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_created_variables\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    620\u001b[0m         raise ValueError(\"Creating variables on a non-first call to a function\"\n",
      "\u001b[0;32m~/.conda/envs/pydl-tf2.2/lib/python3.8/site-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   2418\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_lock\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2419\u001b[0m       \u001b[0mgraph_function\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_maybe_define_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2420\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mgraph_function\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_filtered_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2421\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2422\u001b[0m   \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.conda/envs/pydl-tf2.2/lib/python3.8/site-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m_filtered_call\u001b[0;34m(self, args, kwargs)\u001b[0m\n\u001b[1;32m   1659\u001b[0m       \u001b[0;31m`\u001b[0m\u001b[0margs\u001b[0m\u001b[0;31m`\u001b[0m \u001b[0;32mand\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1660\u001b[0m     \"\"\"\n\u001b[0;32m-> 1661\u001b[0;31m     return self._call_flat(\n\u001b[0m\u001b[1;32m   1662\u001b[0m         (t for t in nest.flatten((args, kwargs), expand_composites=True)\n\u001b[1;32m   1663\u001b[0m          if isinstance(t, (ops.Tensor,\n",
      "\u001b[0;32m~/.conda/envs/pydl-tf2.2/lib/python3.8/site-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m_call_flat\u001b[0;34m(self, args, captured_inputs, cancellation_manager)\u001b[0m\n\u001b[1;32m   1743\u001b[0m         and executing_eagerly):\n\u001b[1;32m   1744\u001b[0m       \u001b[0;31m# No tape is watching; skip to running the function.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1745\u001b[0;31m       return self._build_call_outputs(self._inference_function.call(\n\u001b[0m\u001b[1;32m   1746\u001b[0m           ctx, args, cancellation_manager=cancellation_manager))\n\u001b[1;32m   1747\u001b[0m     forward_backward = self._select_forward_and_backward_functions(\n",
      "\u001b[0;32m~/.conda/envs/pydl-tf2.2/lib/python3.8/site-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36mcall\u001b[0;34m(self, ctx, args, cancellation_manager)\u001b[0m\n\u001b[1;32m    591\u001b[0m       \u001b[0;32mwith\u001b[0m \u001b[0m_InterpolateFunctionError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    592\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mcancellation_manager\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 593\u001b[0;31m           outputs = execute.execute(\n\u001b[0m\u001b[1;32m    594\u001b[0m               \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msignature\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    595\u001b[0m               \u001b[0mnum_outputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_num_outputs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.conda/envs/pydl-tf2.2/lib/python3.8/site-packages/tensorflow/python/eager/execute.py\u001b[0m in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m     57\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     58\u001b[0m     \u001b[0mctx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mensure_initialized\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 59\u001b[0;31m     tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_name,\n\u001b[0m\u001b[1;32m     60\u001b[0m                                         inputs, attrs, num_outputs)\n\u001b[1;32m     61\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Run Each Generation\n",
    "generation_performance = {}\n",
    "for current_generation in range(MAX_GENERATIONS):\n",
    "    print(f\"[+] Generation {current_generation+1} of {MAX_GENERATIONS}\")\n",
    "\n",
    "    # >>>>>> Training Phase <<<<<<\n",
    "    print(f\"\\tTraining Models:\", end='\\n', flush=True)\n",
    "    training_start = time.time()\n",
    "\n",
    "    # Train all Models in Population\n",
    "    for i,individual in enumerate(population):\n",
    "        print(f\"\\t\\tGenerating model for individual {i}\", end='\\n', flush=True)\n",
    "        ga.generate_model_from_chromosome(data, individual)\n",
    "\n",
    "    training_stop = time.time()\n",
    "    print(f\"Done > Takes {training_stop - training_start} sec\", end='\\n')\n",
    "\n",
    "    # >>>>>> Evaluation Phase <<<<<<\n",
    "    print(f\"\\tEvaluating Population: \", end='\\n', flush=True)\n",
    "    evaluation_start = time.time()\n",
    "\n",
    "    for i,individual in enumerate(population):\n",
    "        \n",
    "        print(f\"\\t\\tIndividual {i}\", end='\\n', flush=True)\n",
    "        \n",
    "        # Play the Games\n",
    "        loss, accuracy =  individual.ml_model.evaluate(x=data['x_val'], y=data['y_val']) \n",
    "        \n",
    "        # Update Chromosome Results\n",
    "        individual.loss = loss\n",
    "        individual.accuracy = accuracy\n",
    "        \n",
    "\n",
    "    evaluation_stop = time.time()\n",
    "    print(f\"Done > Takes {evaluation_stop - evaluation_start} sec\", end='\\n')\n",
    "\n",
    "    # Sort Candidates by Sum of Results\n",
    "    population.sort(key=lambda x: x.accuracy, reverse=True)\n",
    "\n",
    "    # Compute Generation Metrics\n",
    "    generation_performance[current_generation] = pd.DataFrame([{'loss':x.loss, 'accuracy': x.accuracy} for x in population ])\n",
    "    \n",
    "    generation_performance[current_generation].describe()\n",
    "\n",
    "    # >>>>>> Genetic Selection, Children Creation and Mutation <<<<<<\n",
    "    if current_generation < MAX_GENERATIONS-1:\n",
    "        population = ga.evolve_population(population)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "evolai",
   "language": "python",
   "name": "evolai"
  },
  "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.16"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}