keras_deep_q_frozen_lake.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Amitabh1989/frozenlake_reinforcement_learning/blob/main/keras_deep_q_frozen_lake.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "llogn2LXqWFS"
      },
      "source": [
        "# Deep Q-Network Route Finder\n",
        "\n",
        "Here in this jupyter notebook, we will have some fun with using reinforcement learning to find safe routes across the ice.\n",
        "This notebook draws a lot of inspiration from Open AI's [FrozenLake](https://gym.openai.com/envs/FrozenLake8x8-v0/) gym environment.\n",
        "Really, how nice of them to have a well crafted toy problem already thought out for us!\n",
        "\n",
        "Specifically and technically, we will train a Deep Q-Network in Keras/Tensorflow to help us decide safe routes across slippery ice!\n",
        "Later, we will move on to applying this safe navigation tool to our crevasse avoidance problem.\n",
        "\n",
        "References:\n",
        "- Open AI [gym](https://github.com/openai/gym) \n",
        "- [Simple Reinforcement Learning with Tensorflow Part 0: Q-Learning with Tables and Neural Networks](https://medium.com/emergent-future/simple-reinforcement-learning-with-tensorflow-part-0-q-learning-with-tables-and-neural-networks-d195264329d0)\n",
        "- [Simple Reinforcement Learning with Tensorflow Part 4: Deep Q-Networks and Beyond](https://medium.com/@awjuliani/simple-reinforcement-learning-with-tensorflow-part-4-deep-q-networks-and-beyond-8438a3e2b8df)\n",
        "- [Frozen Lake github gist using Keras](https://gist.github.com/ceshine/eeb97564c21a77b8c315179f82b3fc08)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 104
        },
        "id": "J16YornYqWFW",
        "outputId": "00519d3c-c4e4-44d9-8cfa-4b3e4c8678a0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Python       : 3.9.16 (main, Dec  7 2022, 01:11:51) \n",
            "Numpy        : 1.22.4\n",
            "Keras        : 2.12.0\n",
            "Tensorflow   : 2.12.0\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'/device:GPU:0'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 1
        }
      ],
      "source": [
        "# Import all the necessary libraries\n",
        "import os\n",
        "import sys\n",
        "import warnings\n",
        "os.environ[\"CUDA_DEVICE_ORDER\"] = \"PCI_BUS_ID\"   # see issue #152\n",
        "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"  #set to see only the first gpu\n",
        "os.environ['KERAS_BACKEND'] = 'tensorflow'\n",
        "warnings.simplefilter(action = \"ignore\", category = FutureWarning)\n",
        "\n",
        "#import gym\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import random\n",
        "%matplotlib inline\n",
        "\n",
        "import keras\n",
        "import tensorflow as tf\n",
        "\n",
        "print('Python       :', sys.version.split('\\n')[0])\n",
        "print('Numpy        :', np.__version__)\n",
        "print('Keras        :', keras.__version__)\n",
        "print('Tensorflow   :', tf.__version__)\n",
        "tf.test.gpu_device_name()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LdHdM_3PqWFY"
      },
      "source": [
        "## Design Keras Model to fit into Q-Network"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "9Sn_9AnvqWFY"
      },
      "outputs": [],
      "source": [
        "# Set seed values\n",
        "seed = 42\n",
        "random.seed = seed\n",
        "np.random.seed(seed=seed)\n",
        "# tf.set_random_seed(seed=seed)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "ltnmmN9aqWFY"
      },
      "outputs": [],
      "source": [
        "from keras import backend as K\n",
        "from keras.models import Sequential, Model\n",
        "from keras.layers import Conv2D, Flatten, Dense, Input, SeparableConv2D\n",
        "from keras.layers.core import Activation, Flatten, Dropout, Reshape\n",
        "#from rl.agents.dqn import DQNAgent\n",
        "#from rl.policy import EpsGreedyQPolicy\n",
        "#from rl.memory import SequentialMemory"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "hKsSpQheqWFZ"
      },
      "outputs": [],
      "source": [
        "def keras_convnet(input_shape=(4,4,2)):\n",
        "    \"\"\"\n",
        "    The Keras Convolutional Network that parses the incoming pixel data.\n",
        "    Consists of 3 Convolutional Layers, and 2 Dense Layers, plus 1 softmax output layer\n",
        "    Note that we use SeparableConv2D layers ala MobileNets for memory efficiency\n",
        "    \n",
        "    Inputs:\n",
        "    input_shape -- shape of the input tensor, (height, width, channels)\n",
        "    \n",
        "    Outputs:\n",
        "    model -- keras.models.Model instance\n",
        "    \n",
        "    \"\"\"\n",
        "    inp = Input(shape=input_shape)\n",
        "    \n",
        "    X = SeparableConv2D(filters=32, kernel_size=(4,4), strides=(1,1), padding='same', activation='relu', use_bias=False)(inp)\n",
        "    X = SeparableConv2D(filters=64, kernel_size=(3,3), strides=(1,1), padding='same', activation='relu', use_bias=False)(X)\n",
        "    X = SeparableConv2D(filters=64, kernel_size=(2,2), strides=(1,1), padding='same', activation='relu', use_bias=False)(X)\n",
        "    \n",
        "    X = Flatten()(X)\n",
        "    X = Dense(units=256, activation='relu', use_bias=False)(X)\n",
        "    X = Dense(units=4, activation='softmax')(X)\n",
        "    \n",
        "    model = Model(inputs=inp, outputs=X) \n",
        "    \n",
        "    return model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BccizopwqWFZ"
      },
      "source": [
        "### Initialize Deep Q-Network parameters"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tRomdNxEqWFa",
        "outputId": "394e9d74-0fea-4292-a175-67e2298c58aa"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input_1 (InputLayer)        [(None, 4, 4, 2)]         0         \n",
            "                                                                 \n",
            " separable_conv2d (Separable  (None, 4, 4, 32)         96        \n",
            " Conv2D)                                                         \n",
            "                                                                 \n",
            " separable_conv2d_1 (Separab  (None, 4, 4, 64)         2336      \n",
            " leConv2D)                                                       \n",
            "                                                                 \n",
            " separable_conv2d_2 (Separab  (None, 4, 4, 64)         4352      \n",
            " leConv2D)                                                       \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 1024)              0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 256)               262144    \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 4)                 1028      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 269,956\n",
            "Trainable params: 269,956\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "None\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.9/dist-packages/keras/optimizers/legacy/adam.py:117: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
            "  super().__init__(name, **kwargs)\n"
          ]
        }
      ],
      "source": [
        "# DQN model parameters\n",
        "model = keras_convnet()\n",
        "print(model.summary())\n",
        "#policy = EpsGreedyQPolicy(eps=0.1)\n",
        "#nb_actions = env.action_space.n\n",
        "#memory = SequentialMemory(limit=10000, window_length=4)\n",
        "\n",
        "# DQN runtime parameters\n",
        "def sum_squared_loss(yTrue, yPred):\n",
        "    return K.sum(K.square(yTrue - yPred))\n",
        "loss = sum_squared_loss\n",
        "optimizer = keras.optimizers.Adam(lr=0.001)\n",
        "\n",
        "# Compile keras model\n",
        "model.compile(loss=loss, optimizer=optimizer)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w_7d9xBeqWFa"
      },
      "source": [
        "# Pure numpy implementation of Open AI Frozen Lake, plus a Keras Deep Q-network"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "msdAA7hCqWFb"
      },
      "source": [
        "### Helper function to convert integer to a 2D grid location"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LBDsz_CIqWFb",
        "outputId": "4afaa108-4e0d-4d16-e34f-9eadf1710e02"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 0., 0., 0.],\n",
              "       [0., 1., 0., 0.],\n",
              "       [0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0.]])"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ],
      "source": [
        "def int_to_grid(integer, grid_shape=(4,4)):\n",
        "    \"\"\"\n",
        "    Function to map an integer to it's 2D grid location\n",
        "    \n",
        "    E.g. to place the integer 5 in a 4x4 (height*width) grid\n",
        "    \n",
        "            0000\n",
        "    5   ->  0100\n",
        "            0000\n",
        "            0000\n",
        "            \n",
        "    Steps:\n",
        "    1) np.prod(grid_shape) i.e. 4*4=16\n",
        "    2) np.identity(16)[integer:integer+1] i.e. output something like [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0]\n",
        "    3) np.reshape(grid_shape) i.e. output the grid form of the above\n",
        "    \"\"\"\n",
        "    return np.identity(np.prod(grid_shape))[integer:integer+1].reshape(grid_shape)\n",
        "int_to_grid(5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ITDmj1UOqWFb"
      },
      "source": [
        "### The player step left, down, right, up dynamics"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "hv2AK5LfqWFc"
      },
      "outputs": [],
      "source": [
        "def player_step(old_position:np.array, action:int):\n",
        "    \"\"\"\n",
        "    Take a step somewhere, unless you'll go through the wall!\n",
        "    \n",
        "    Inputs:\n",
        "    old_position -- a (height, width) shaped numpy array of 0s with a 1 marking the player position\n",
        "    action -- an integer from 0 to 3 representing either Left, Down, Right, Up\n",
        "    \n",
        "    Outputs:\n",
        "    new_position -- a (height, width) shaped numpy array of 0s with a 1 marking the player position\n",
        "    \n",
        "    Example taking a step Right:\n",
        "    \n",
        "           old_position                        new_position  \n",
        "    array([[0., 0., 0., 0.],            array([[0., 0., 0., 0.],\n",
        "           [0., 1., 0., 0.],    ----\\          [0., 0., 1., 0.],\n",
        "           [0., 0., 0., 0.],    ----/          [0., 0., 0., 0.],\n",
        "           [0., 0., 0., 0.]])                  [0., 0., 0., 0.]])\n",
        "    \"\"\"\n",
        "    actionKeys = {0:\"Left <-\", 1:\"Down v\", 2:\"Right ->\", 3:\"Up ^\"}\n",
        "    position = np.argmax(old_position)\n",
        "    \n",
        "    assert(len(old_position.shape) == 2)  #numpy array shape must be (height, width) i.e. 2 dimensional\n",
        "    \n",
        "    if actionKeys[action] == 'Left <-':\n",
        "        #print('Going Left')\n",
        "        #move left unless you are at the left wall\n",
        "        new_pos = position - 1 if (position)%map_grid.shape[1] != 0 else position\n",
        "    \n",
        "    if actionKeys[action] == 'Down v':\n",
        "        #print('Going Down')\n",
        "        #move down unless you are at the bottom wall\n",
        "        new_pos = position + map_grid.shape[0] if position + map_grid.shape[0] < np.prod(map_grid.shape) else position\n",
        "    \n",
        "    if actionKeys[action] == 'Right ->':\n",
        "        #print('Going Right')\n",
        "        #move right unless you are at the right wall\n",
        "        new_pos = position + 1 if (position+1)%map_grid.shape[1] != 0 else position\n",
        "\n",
        "    if actionKeys[action] == 'Up ^':\n",
        "        #print('Going Up')\n",
        "        #move up unless you are at the upper wall\n",
        "        new_pos = position - map_grid.shape[0] if position - map_grid.shape[0] > 0 else position\n",
        "    \n",
        "    assert(new_pos in range(np.prod(map_grid.shape)))  #final check to see that we are within the grid range\n",
        "    new_position = int_to_grid(new_pos)                #change our \n",
        "    \n",
        "    return new_position"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n-HGcAcjqWFc"
      },
      "source": [
        "### Initialize some variables and train the Deep Q-Network!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TFwuc4A1qWFc",
        "outputId": "191d5928-43b6-4515-c58d-d133e1ab1935"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-9-d6ea28cda374>:12: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
            "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
            "  [5.0, 0.0, 0.0, -5.]], dtype=np.float)  #note that our map is inverse coded so -ve values are good and +ve values are bad!\n"
          ]
        }
      ],
      "source": [
        "# Environment variables, replicated from https://gym.openai.com/envs/FrozenLake-v0/\n",
        "actionKeys = {0:\"Left <-\", 1:\"Down v\", 2:\"Right ->\", 3:\"Up ^\"}\n",
        "'''\n",
        "SFFF       (S: starting point, safe)\n",
        "FHFH       (F: frozen surface, safe)\n",
        "FFFH       (H: hole, fall to your doom)\n",
        "HFFG       (G: goal, where the frisbee is located)\n",
        "'''\n",
        "map_grid = np.array([[0.0, 0.0, 0.0, 0.0],\n",
        "                     [0.0, 5.0, 0.0, 5.0],\n",
        "                     [0.0, 0.0, 0.0, 5.0],\n",
        "                     [5.0, 0.0, 0.0, -5.]], dtype=np.float)  #note that our map is inverse coded so -ve values are good and +ve values are bad!\n",
        "\n",
        "\n",
        "#Hyperparameters\n",
        "epsilon = 0.75       #Exploration setting between 0 and 1, where 0 is don't explore and 1 is explore please!\n",
        "gamma = 0.99         #Future discount factor between 0 and 1, where 0 means care only about now, and 1 means I care alot about the future!\n",
        "\n",
        "#Session parameters\n",
        "num_episodes = 2000\n",
        "rewardList = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pLynuot3qWFc"
      },
      "outputs": [],
      "source": [
        "print(\"Begin training Deep Q-Network!!\")\n",
        "for i in range(num_episodes):\n",
        "#for i in range(1):  #use if you only want to see one episode!\n",
        "    player_position = int_to_grid(0)   #we start the player at the topleft corner of our map_grid\n",
        "    current_state = np.stack([np.stack([player_position, map_grid], axis=-1)])  #stack the player_position array and map_grid array channel/depth-wise\n",
        "    assert(current_state.shape == (1,4,4,2))                                    #check that our input current_state has shape (batch_size, rows, cols, channels)\n",
        "    rewardTally = 0  #start reward Score at 0\n",
        "    j = 0            #counter in case our agent does too many stupid moves\n",
        "    while j < 32:    #limit the number of moves our agent can take to 32\n",
        "        j += 1\n",
        "        \n",
        "        #########################################################################\n",
        "        #Our Deep Q-Network takes an input state (x) of the environment and\n",
        "        #predicts an output list of Q-values (y) representing the 'q'uality of\n",
        "        #the actions we can take the move the player around the map grid        \n",
        "        \n",
        "        #########################################################################\n",
        "        ## Feed current state into Deep Q-Network\n",
        "        current_state_Q_values = model.predict(x=current_state, batch_size=1)    #Use our neural network to get the Q values for each possible move given the current player position and map_grid\n",
        "        #print(current_state_Q_values)                                           #outputs the Q values for our possible moves left, down, right, up as an array e.g. [[0.23, 0.22, 0.24, 0.26]]\n",
        "        \n",
        "        ## Decide what action to perform based on current_state_Q_values, and randomize with epsilon\n",
        "        action = np.argmax(current_state_Q_values)                               #find the maximum/greatest Q value to decide what action to take\n",
        "        if np.random.rand(1) < epsilon:                                          #if some random number is less than our epsilon value\n",
        "            action = int(np.random.uniform(low=0, high=4))                       #we get a new action randomly from a uniform distribution!\n",
        "        #print(actionKeys[action])\n",
        "        \n",
        "        ## Take a step towards somewhere\n",
        "        player_position = player_step(old_position=player_position, action=action)\n",
        "        #print(player_position)  #uncomment to see player position!\n",
        "        \n",
        "        ## Get new future state (stack of player_postion and map_grid representing our observation of the environment) and reward associated with it\n",
        "        future_state = np.stack([np.stack([player_position, map_grid], axis=-1)])\n",
        "        reward = -map_grid.ravel()[np.argmax(player_position)]                    #note that we do a negative here, because dangerous holes are mapped +ve in our map\n",
        "        rewardTally += reward\n",
        "        #print(rewardTally)\n",
        "        \n",
        "        ## Check if we fell in the hole, else continue\n",
        "        if rewardTally <= -5.0:\n",
        "            break\n",
        "        \n",
        "        #########################################################################\n",
        "        ## Feed the future state into Deep Q-Network and get max Q value from it\n",
        "        future_state_Q_values = model.predict(x=future_state, batch_size=1)\n",
        "        future_state_max_Q = np.max(future_state_Q_values)\n",
        "        #print(future_state_max_Q)\n",
        "        \n",
        "        ## Implement Bellman equation here!! Q(s,a) = r + γ(max(Q(s’,a’))\n",
        "        #Basically, the Q-value for a given state (s) and action (a) should represent the current reward (r) plus the maximum discounted (γ) future reward expected\n",
        "        target_Q = current_state_Q_values                       #set our target to the current_state first\n",
        "        target_Q[0,action] = reward + gamma*future_state_max_Q  #replace the single Q-value at the index position of the action taken\n",
        "        \n",
        "        ## Retrain our Keras Deep Q-Network to learn this new target Q value\n",
        "        model.fit(x=current_state, y=target_Q, verbose=0, batch_size=1)\n",
        "        \n",
        "        ## Check if we are done (reached goal), otherwise continue\n",
        "        if rewardTally > 0:\n",
        "            epsilon = epsilon - (0.02)  #Reduce (by hardcoded amount) epsilon value, i.e. the chance of random action as we train the model.\n",
        "            break\n",
        "        \n",
        "        ## Set the next current_state as our current future_state\n",
        "        current_state = future_state\n",
        "    \n",
        "    ## After finishing an episode... \n",
        "    rewardList.append(rewardTally) #we append the rewardTally for the episode to the rewardList\n",
        "    \n",
        "    ## Some print information\n",
        "    if i%500==0 and i!=0:\n",
        "        print(f\"Step: {i-500} to {i}, with epsilon: {epsilon}\")\n",
        "        plt.plot(rewardList[-500:])  #plot the 500 last rewardTally-s\n",
        "        plt.show()\n",
        "\n",
        "#Show final score\n",
        "success = len([r for r in rewardList if r == 5])   #when we reached the goal\n",
        "#failure = len([r for r in rewardList if r == 0])  #when we reached nowhere\n",
        "epicfail = len([r for r in rewardList if r == -5]) #when we dropped into a hole\n",
        "\n",
        "print(\"Percent of succesful episodes: \" + str(success/num_episodes) + \"%\")\n",
        "plt.plot(rewardList[-num_episodes:])\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ekCkZA8QqWFd"
      },
      "source": [
        "### See how our player does"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "lCo_kn5gqWFd"
      },
      "outputs": [],
      "source": [
        "def plot_player_and_map(player_position, map_grid):\n",
        "    \"\"\"\n",
        "    Matplotlib function to plot the player position on the left\n",
        "    and the map_grid position on the right\n",
        "    \"\"\"\n",
        "    assert(player_position.shape == map_grid.shape)\n",
        "    \n",
        "    fig, axarr = plt.subplots(nrows=1, ncols=2, squeeze=False, figsize=(5,5))\n",
        "    axarr[0, 0].imshow(X=player_position, cmap='winter')\n",
        "    axarr[0, 1].imshow(X=-map_grid, cmap='BrBG')\n",
        "    \n",
        "    return plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 236
        },
        "id": "OunJKOd8qWFd",
        "outputId": "8eba02c2-232a-4bf8-c905-330902934d5d"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 500x500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "player_position = int_to_grid(0)   #we start the player at the topleft corner of our map_grid\n",
        "plot_player_and_map(player_position=player_position, map_grid=map_grid)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "4cIS6X4uqWFe",
        "outputId": "5ae56222-8bbd-44d0-bf99-8b2f2e74b97e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 21ms/step\n",
            "Down v\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 500x500 with 2 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaoAAADbCAYAAAA8htUmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAOLUlEQVR4nO3dUWhT99/H8U+q/0bBJKw4K6HpFATB/x47qFbCxthcp08HTu92t+p29RCF0av1Zj53EXajbEWEDXtVFIQqyKNOutlSsKiVgvowQfCi0LWdsCUxYHTJeS7Ubj62ek6bk/PN6fsFAU92kt8Hl6+fnuSkJ+I4jiMAAIxqCDoAAACvQlEBAEyjqAAAplFUAADTKCoAgGkUFQDANIoKAGDaylovWKlUNDU1pVgspkgkUuvlgSVxHEeFQkHJZFINDcH+nMcsoZ55maWaF9XU1JRSqVStlwWqanJyUi0tLYFmYJYQBm5mqeZFFYvFnv1pUlK81ssDS5SXlPrH6zg4zzPcvXvXRB7Ai0KhoM2bN7t67da8qP5+iyIuigr1ysJbbc8zxGIxxePMEuqTm1niZAoAgGkUFQDANIoKAGAaRQUAMI2iAgCYRlEBAEyjqAAAplFUAADTKCoAgGkUFQDANIoKAGAaRQUAMI2iAgCYRlEBAEyjqAAAplFUAADTFlVUfX192rBhg1atWqUdO3bo2rVr1c4FLAvMEvB6novq9OnT6unp0eHDh3Xz5k21tbVp9+7dmp2d9SMfEFrMEuBOxHEcx8sDduzYoe3bt+v777+XJFUqFaVSKR06dEhff/31S/uXSiWVSqW57Xw+r1QqJSknLkWP+pOXlFAul1vy5d+rNUtTU1Ncih51J5/PK5lMupolT0dUjx8/1vj4uDo7O/9+goYGdXZ26urVq/M+JpvNKpFIzN2elhSwvDFLgHueiurBgwcql8tqbm5+4f7m5mZNT0/P+5je3l7lcrm52+Tk5OLTAiHBLAHurfR7gWg0qmg06vcyQOgxS1iuPB1RrV27VitWrNDMzMwL98/MzGj9+vVVDQaEGbMEuOepqBobG9Xe3q6hoaG5+yqVioaGhpROp6seDggrZglwz/Nbfz09Peru7ta2bdvU0dGho0ePqlgs6sCBA37kA0KLWQLc8VxUn332mX7//Xd98803mp6e1jvvvKOLFy++9KEwgFdjlgB3PH+Paqny+bwSiYT4HhXqU/W+R7XkJM9mie9RoR759j0qAABqjaICAJhGUQEATKOoAACmUVQAANMoKgCAaRQVAMA0igoAYBpFBQAwjaICAJhGUQEATKOoAACmUVQAANN8vxT9gnJZKV4nl9WO/HfQCYBQ2P/eG0FH8KR/9I+gI3hWL3/HT8ruL9zBERUAwDSKCgBgGkUFADCNogIAmEZRAQBMo6gAAKZRVAAA0ygqAIBpFBUAwDSKCgBgGkUFADCNogIAmEZRAQBMo6gAAKZRVAAA0ygqAIBpFBUAwDSKCgBgGkUFADDNc1GNjIxoz549SiaTikQiOnv2rA+xgPBjlgB3PBdVsVhUW1ub+vr6/MgDLBvMEuDOSq8P6OrqUldXl+v9S6WSSqXS3HY+n/e6JBBKzBLgju+fUWWzWSUSiblbKpXye0kglJglLFe+F1Vvb69yudzcbXJy0u8lgVBilrBceX7rz6toNKpoNOr3MkDoMUtYrjg9HQBgGkUFADDN81t/Dx8+1L179+a279+/r4mJCTU1Nam1tbWq4YAwY5YAdzwX1Y0bN/Thhx/Obff09EiSuru71d/fX7VgQNgxS4A7novqgw8+kOM4fmQBlhVmCXCHz6gAAKZRVAAA0ygqAIBpFBUAwDSKCgBgGkUFADCNogIAmEZRAQBMo6gAAKZRVAAA0ygqAIBpFBUAwDSKCgBgmu+Xol9QoldSPLDlAdRe/+gfQUdAHeKICgBgGkUFADCNogIAmEZRAQBMo6gAAKZRVAAA0ygqAIBpFBUAwDSKCgBgGkUFADCNogIAmEZRAQBMo6gAAKZRVAAA0ygqAIBpFBUAwDSKCgBgGkUFADCNogIAmOapqLLZrLZv365YLKZ169Zp3759unv3rl/ZgNBilgD3PBXV8PCwMpmMxsbGdPnyZT158kS7du1SsVj0Kx8QSswS4N5KLztfvHjxhe3+/n6tW7dO4+Pjev/99+d9TKlUUqlUmtvO5/OLiAmEC7MEuLekz6hyuZwkqampacF9stmsEonE3C2VSi1lSSCUmCVgYRHHcZzFPLBSqejTTz/Vn3/+qdHR0QX3m++nwKcDlpMUX8zSQIDykhLK5XKKx6vz+l3qLE1NTVUtC+rf/vfeCDqCK0/Kjs7d+svVLHl66++fMpmMbt++/crBkqRoNKpoNLrYZYDQY5aAV1tUUR08eFDnz5/XyMiIWlpaqp0JWDaYJeD1PBWV4zg6dOiQBgcHdeXKFW3cuNGvXECoMUuAe56KKpPJaGBgQOfOnVMsFtP09LQkKZFIaPXq1b4EBMKIWQLc83QyRSQSmff+kydPav/+/a6eI5/PK5FIiJMpUJ+qczJFNWeJkynwT8v+ZIpFniAI4P9hlgD3+F1/AADTKCoAgGkUFQDANIoKAGAaRQUAMI2iAgCYRlEBAEyjqAAAplFUAADTKCoAgGkUFQDANIoKAGAaRQUAMI2iAgCYtqhL0QOw4792t+pfK+a/vpU1/aN/BB0h9M6s+XfQEdz5qyzplqtdOaICAJhGUQEATKOoAACmUVQAANMoKgCAaRQVAMA0igoAYBpFBQAwjaICAJhGUQEATKOoAACmUVQAANMoKgCAaRQVAMA0igoAYBpFBQAwjaICAJhGUQEATPNUVMePH9fWrVsVj8cVj8eVTqd14cIFv7IBocY8Ae54KqqWlhYdOXJE4+PjunHjhnbu3Km9e/fqzp07fuUDQot5AtyJOI7jLOUJmpqa9O233+rLL7+c97+XSiWVSqW57Xw+r1QqJSknKb6UpYEA5CUllMvlFI9X//X7qnlaaJb2/sdK/WtFpOpZ/NA/+kfQEUJvzX++F3QEd/4qS2O3XM3Soj+jKpfLOnXqlIrFotLp9IL7ZbNZJRKJudvTkgLwT27miVnCcuX5iOrWrVtKp9N69OiR1qxZo4GBAX3yyScL7s8RFcKlukdUXuaJIyq4EcYjqpVen3vz5s2amJhQLpfTmTNn1N3dreHhYW3ZsmXe/aPRqKLRqNdlgGXByzwxS1iuPBdVY2OjNm3aJElqb2/X9evXdezYMZ04caLq4YCwY56A11vy96gqlcoLb0cAWDzmCXiZpyOq3t5edXV1qbW1VYVCQQMDA7py5YouXbrkVz4gtJgnwB1PRTU7O6vPP/9cv/32mxKJhLZu3apLly7p448/9isfEFrME+COp6L68ccf/coBLDvME+AOv+sPAGAaRQUAMI2iAgCYRlEBAEyjqAAAplFUAADTKCoAgGkUFQDANIoKAGAaRQUAMI2iAgCYRlEBAEyjqAAApnm+wu9SOY7z7E/5Wi8NVMHT1+3fr+PgPM/wpBx8Frfyeebed3+Vg07gzrOcbmap5kVVKBSe/SlV66WBqikUCkokEoFnkKT/+d86+YdJ0rlkMugIMMbNLEWcGv9oWKlUNDU1pVgspkgkUrXnzefzSqVSmpycVDwer9rz+oW8/vIrr+M4KhQKSiaTamgI9p1zZukp8vrLwizV/IiqoaFBLS0tvj1/PB6vi//5z5HXX37kDfpI6jlm6UXk9VeQs8TJFAAA0ygqAIBpoSmqaDSqw4cPKxqNBh3FFfL6q97yWlJvf3fk9ZeFvDU/mQIAAC9Cc0QFAAgnigoAYBpFBQAwjaICAJhGUQEATAtFUfX19WnDhg1atWqVduzYoWvXrgUdaUEjIyPas2ePksmkIpGIzp49G3SkBWWzWW3fvl2xWEzr1q3Tvn37dPfu3aBjLej48ePaunXr3Dfo0+m0Lly4EHSsusIs+Yd5Wry6L6rTp0+rp6dHhw8f1s2bN9XW1qbdu3drdnY26GjzKhaLamtrU19fX9BRXmt4eFiZTEZjY2O6fPmynjx5ol27dqlYLAYdbV4tLS06cuSIxsfHdePGDe3cuVN79+7VnTt3go5WF5glfzFPS+DUuY6ODieTycxtl8tlJ5lMOtlsNsBU7khyBgcHg47h2uzsrCPJGR4eDjqKa2+88Ybzww8/BB2jLjBLtcU8uVfXR1SPHz/W+Pi4Ojs75+5raGhQZ2enrl69GmCycMrlcpKkpqamgJO8Xrlc1qlTp1QsFpVOp4OOYx6zVHvMk3s1/+3p1fTgwQOVy2U1Nze/cH9zc7N+/fXXgFKFU6VS0VdffaV3331Xb7/9dtBxFnTr1i2l02k9evRIa9as0eDgoLZs2RJ0LPOYpdpinryp66JC7WQyGd2+fVujo6NBR3mlzZs3a2JiQrlcTmfOnFF3d7eGh4cpK5jCPHlT10W1du1arVixQjMzMy/cPzMzo/Xr1weUKnwOHjyo8+fPa2RkxNfrH1VDY2OjNm3aJElqb2/X9evXdezYMZ04cSLgZLYxS7XDPHlX159RNTY2qr29XUNDQ3P3VSoVDQ0N8blEFTiOo4MHD2pwcFA///yzNm7cGHQkzyqVikqlUtAxzGOW/Mc8LV5dH1FJUk9Pj7q7u7Vt2zZ1dHTo6NGjKhaLOnDgQNDR5vXw4UPdu3dvbvv+/fuamJhQU1OTWltbA0z2skwmo4GBAZ07d06xWEzT09OSnl6Vc/Xq1QGne1lvb6+6urrU2tqqQqGggYEBXblyRZcuXQo6Wl1glvzFPC1Bzc8z9MF3333ntLa2Oo2NjU5HR4czNjYWdKQF/fLLL46kl27d3d1BR3vJfDklOSdPngw62ry++OIL56233nIaGxudN9980/noo4+cn376KehYdYVZ8g/ztHhcjwoAYFpdf0YFAAg/igoAYBpFBQAwjaICAJhGUQEATKOoAACmUVQAANMoKgCAaRQVAMA0igoAYBpFBQAw7f8A1HlugHrULrgAAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 25ms/step\n",
            "Down v\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 500x500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 29ms/step\n",
            "Right ->\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 500x500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 27ms/step\n",
            "Down v\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 500x500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 28ms/step\n",
            "Right ->\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 500x500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 30ms/step\n",
            "Right ->\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 500x500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "for i in range(6):  #take 6 steps and see if our player reaches the goal!\n",
        "    #plot_player_and_map(player_position=player_position, map_grid=map_grid)\n",
        "    current_state = np.stack([np.stack([player_position, map_grid], axis=-1)])\n",
        "    current_state_Q_values = model.predict(x=current_state, batch_size=1)\n",
        "    action = np.argmax(current_state_Q_values)\n",
        "    print(actionKeys[action])\n",
        "    player_position = player_step(old_position=player_position, action=action)\n",
        "    plot_player_and_map(player_position=player_position, map_grid=map_grid)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FDfck9NAqWFe"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}