cartPole/cartPole4GeneticAlgorithm.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solving Cart Pole in 10 minutes with a Genetic Algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GaCW4Zqerspc"
   },
   "outputs": [],
   "source": [
    "# Imports the libraries:\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib as mpl\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "import random\n",
    "import gym\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "NvD7jmvOrVc3"
   },
   "outputs": [],
   "source": [
    "def createRandomIndividuals (numberOfIndividuals, numberOfParameters, low=-1, high=1):\n",
    "    parameters = np.random.uniform (low=low, high = high, size = (numberOfParameters, numberOfIndividuals))\n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kULibDr5r9w7"
   },
   "outputs": [],
   "source": [
    "def elitismSelection (parameters, numberToBeChosen, shapes, paramsPerShape):\n",
    "    scores  = [getCartPoleFitness(parameters[:,i], shapes, paramsPerShape) for i in range(parameters.shape[1])]\n",
    "    indices = np.argsort (scores)[::-1] ## Really important for descending order!\n",
    "    parameters      = parameters[:,indices[:numberToBeChosen]]\n",
    "    print (\"Best individual reward: %d\" % scores[indices[0]])\n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createPairs (numberOfSurvivors, numberOfPairs, replace=True): # It returns a list of indices that can be splitted every 2 for forming pairs\n",
    "    pairs = []\n",
    "    chosenIndices = np.random.choice (range(numberOfSurvivors), size=(numberOfPairs*2), replace = replace)\n",
    "    return chosenIndices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "c36el2OS3FdK"
   },
   "outputs": [],
   "source": [
    "def SBX (parameters1, parameters2, eta=100): # Simulated Binary Crossover. The bigger is eta, the more close the children are to parents\n",
    "\n",
    "    r             = np.random.random(size=len(parameters1))\n",
    "    gamma         = np.empty(len(parameters1))\n",
    "    gamma[r<=0.5] = (2*r[r<=0.5])**(1/(eta+1))\n",
    "    gamma[r>0.5 ] = (1/(2*(1-r[r>0.5])))**(1/(eta+1))\n",
    "    child1        = 0.5 * ((1+gamma)*parameters1 + (1-gamma)*parameters2)\n",
    "    child2        = 0.5 * ((1-gamma)*parameters1 + (1+gamma)*parameters2)\n",
    "    return child1, child2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "snagO8f4qORR"
   },
   "outputs": [],
   "source": [
    "def applyGaussianMutation (parameters, mutation_rate=0.05, mu=0, sigma=1): # Pass it a numpy array of floats! (mu and sigma can be arrays too)\n",
    "    mutationOrNot              = (np.random.random (size=len(parameters))) < mutation_rate\n",
    "    mutationValues             = np.random.normal(loc=mu, scale = sigma, size = len(parameters))\n",
    "    parameters[mutationOrNot] += mutationValues[mutationOrNot]\n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "stateInput = keras.Input(shape = (4))\n",
    "\n",
    "dense1 = keras.layers.Dense(units = 64, activation = \"relu\") (stateInput)\n",
    "dense2 = keras.layers.Dense(units = 64, activation = \"relu\") (dense1)\n",
    "dense3 = keras.layers.Dense(units = 64, activation = \"relu\") (dense2)\n",
    "\n",
    "outputLayer = keras.layers.Dense (units = 2) (dense3)\n",
    "\n",
    "model = keras.Model (inputs = stateInput, outputs = outputLayer)\n",
    "model.compile(optimizer=keras.optimizers.Adam(lr=0.001),loss =\"mse\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getLengthOfWeights (model):\n",
    "    setsOfWeights = np.array(model.get_weights())\n",
    "    totalWeights = 0\n",
    "    shapes = []\n",
    "    paramsPerShape = []\n",
    "    for i in setsOfWeights:\n",
    "        shapes.append(i.shape)\n",
    "        i = np.reshape (i, (-1))\n",
    "        totalWeights += i.shape[0]\n",
    "        paramsPerShape.append(i.shape[0])\n",
    "    return totalWeights, shapes, paramsPerShape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def setModelWeights(parameters, shapes, paramsPerShape):\n",
    "    weights = []\n",
    "    paramsUsedSoFar = 0\n",
    "    for index, shape in enumerate (shapes):\n",
    "        paramsInThisLayer = paramsPerShape[index]\n",
    "        params = np.reshape (parameters[paramsUsedSoFar:paramsUsedSoFar+paramsInThisLayer], shape)\n",
    "        weights.append(params)\n",
    "        paramsUsedSoFar += paramsInThisLayer\n",
    "    model.set_weights(weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getCartPoleFitness (parameters, shapes, paramsPerShape):\n",
    "    \n",
    "    setModelWeights (parameters, shapes, paramsPerShape)\n",
    "\n",
    "    env = gym.make('CartPole-v1')\n",
    "\n",
    "    done = False\n",
    "    cartPoleReward = 0\n",
    "    prevObs = np.expand_dims(env.reset(),axis=0)\n",
    "\n",
    "    for step in range(502):\n",
    "        if (done):\n",
    "            break  \n",
    "          \n",
    "        action = np.argmax(model.predict(prevObs))\n",
    "\n",
    "        state, reward, done,_ = env.step(action)\n",
    "     \n",
    "        prevObs = np.expand_dims(state,axis=0)\n",
    "       \n",
    "        cartPoleReward += reward\n",
    "    \n",
    "    env.close()\n",
    "    return cartPoleReward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nQ6aEU3iNeQu"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generation 1 starting\n",
      "Best individual reward: 73\n",
      "Generation 2 starting\n",
      "Best individual reward: 94\n",
      "Generation 3 starting\n",
      "Best individual reward: 168\n",
      "Generation 4 starting\n",
      "Best individual reward: 224\n",
      "Generation 5 starting\n",
      "Best individual reward: 500\n",
      "Generation 6 starting\n",
      "Best individual reward: 490\n",
      "Generation 7 starting\n",
      "Best individual reward: 500\n",
      "Generation 8 starting\n",
      "Best individual reward: 500\n",
      "Generation 9 starting\n",
      "Best individual reward: 500\n",
      "Generation 10 starting\n",
      "Best individual reward: 500\n",
      "Generation 11 starting\n",
      "Best individual reward: 500\n",
      "Generation 12 starting\n",
      "Best individual reward: 500\n",
      "Generation 13 starting\n",
      "Best individual reward: 500\n",
      "Generation 14 starting\n",
      "Best individual reward: 500\n",
      "Generation 15 starting\n",
      "Best individual reward: 500\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "500.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numberOfGenerations = 15\n",
    "indivPerGen         = 30\n",
    "fittestNumber       = 10\n",
    "\n",
    "childrenFromParents = 20\n",
    "parentsThatRemain   = 5\n",
    "numberNewIndividuals= 5\n",
    "\n",
    "mu = 0\n",
    "sigma = 0.2\n",
    "\n",
    "\n",
    "totalWeights, shapes, paramsPerShape = getLengthOfWeights (model)\n",
    "\n",
    "primitiveGeneration = createRandomIndividuals (numberOfIndividuals=indivPerGen, numberOfParameters = totalWeights, low=-1, high=1)\n",
    "# Shape (NumberOfWeights, indivPerGen).\n",
    "\n",
    "pastGeneration   = np.copy(primitiveGeneration)\n",
    "\n",
    "for i in range (numberOfGenerations):\n",
    "    print (\"Generation %d starting\" % (i+1))\n",
    "    # Choose one selection type:\n",
    "    mutation_rate = 0.05/np.cbrt(i+1)\n",
    "    survivors    = elitismSelection (pastGeneration, numberToBeChosen=fittestNumber, shapes=shapes, paramsPerShape = paramsPerShape)\n",
    "    # Shape (NumberOfWeights, fittestNumber)\n",
    "\n",
    "    pairs        = createPairs (numberOfSurvivors=fittestNumber, numberOfPairs = childrenFromParents//2, replace=True)\n",
    "    # Shape (childrenFromParents,). Contains indices for survivors Array ready to be splitted every two.\n",
    "\n",
    "    newChildren  = []\n",
    "\n",
    "    for i in range (childrenFromParents//2):\n",
    "\n",
    "        parents  = survivors[:,pairs[2*i:2*(i+1)]]\n",
    "        # Shape (NumberOfWeights, numberOfParents)\n",
    "        \n",
    "        child1, child2 = SBX (parents[:,0], parents[:,1]) \n",
    "    \n",
    "        # Choose one mutation type:\n",
    "\n",
    "        child1, child2 = applyGaussianMutation (child1, mutation_rate=mutation_rate,mu=mu, sigma=sigma), applyGaussianMutation (child2,mutation_rate=mutation_rate, mu=mu, sigma=sigma)\n",
    "\n",
    "\n",
    "        newChildren.append(child1)\n",
    "        newChildren.append(child2)\n",
    "    \n",
    "    newChildren    = np.swapaxes(newChildren, axis1=1, axis2=0)\n",
    "    # Shape (NumberOfWeights, ChildrenFromParents).\n",
    "\n",
    "    newIndividuals = createRandomIndividuals (numberNewIndividuals, numberOfParameters = totalWeights, low=-1, high=1)\n",
    "    # Shape (NumberOfWeights, numberNewIndividuals)\n",
    "    \n",
    "    newGeneration  = np.concatenate ((survivors[:,:parentsThatRemain],newChildren, newIndividuals), axis = 1)\n",
    "    # Shape (NumberOfWeights, indivPerGen)\n",
    "\n",
    "    pastGeneration = np.copy(newGeneration)\n",
    "getCartPoleFitness(survivors[:,0], shapes, paramsPerShape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def testEnvironment ():\n",
    "    rewards = []\n",
    "    for episode in range (100):\n",
    "        env = gym.make('CartPole-v1')\n",
    "\n",
    "        done = False\n",
    "        cartPoleReward = 0\n",
    "        prevObs = np.expand_dims(env.reset(),axis=0)\n",
    "\n",
    "        for step in range(502):\n",
    "            if (done):\n",
    "                break  \n",
    "            #env.render()\n",
    "            action = np.argmax(model.predict(prevObs))\n",
    "\n",
    "            state, reward, done,_ = env.step(action)\n",
    "\n",
    "            prevObs = np.expand_dims(state,axis=0)\n",
    "\n",
    "            cartPoleReward += reward\n",
    "        env.close()\n",
    "        rewards.append(cartPoleReward)\n",
    "        \n",
    "    \n",
    "    plt.plot (list(range(len(rewards))),rewards)\n",
    "    plt.plot (list(range(len(rewards))), [np.average(rewards)]*len(rewards))\n",
    "    plt.title(\"Rewards obtained during Testing\")\n",
    "    plt.xlabel(\"Episode number\")\n",
    "    plt.ylabel(\"Reward obtained\")\n",
    "    plt.legend([\"Rewards\", \"Average: %.2f\" % np.average(rewards)])\n",
    "    plt.show()\n",
    "testEnvironment()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "GeneticFunction.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}