Cliff_v4_policyImprovementRevise.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Cliff_v4_policyImprovementRevise",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyMFRVwSNdODfMlHCio6exlm",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/needs-searcher/RL_Example/blob/master/Cliff_v4_policyImprovementRevise.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "knPYCQAGIRVD"
      },
      "source": [
        "# rule\n",
        "# undiscounted, episodic\n",
        "# start, goal states exist\n",
        "# actions : up, down, right, left\n",
        "# R = -1 at all transition\n",
        "# R = -100 at cliff region and go to start point"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BNbUyFZrIVqy"
      },
      "source": [
        "import numpy as np\n",
        "from collections import defaultdict\n",
        "\n",
        "gamma = 1\n",
        "alpa = 0.1\n",
        "#epsilon = 0.1\n",
        "\n",
        "# define state\n",
        "start_key = (3,0)\n",
        "state = defaultdict(lambda : 0)\n",
        "\n",
        "for i in range(4):\n",
        "    for j in range(12):\n",
        "        if i == 3 and j>=1 and j<11:\n",
        "            state[(i,j)] = -1\n",
        "        else:\n",
        "            state[(i,j)] = 0\n",
        "\n",
        "# define action \n",
        "actions = [\"up\", \"down\", \"left\", \"right\"]"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t67E5ak9IZhR"
      },
      "source": [
        "# s' function\n",
        "def nxtstateKey(state_key, action):\n",
        "  origin = state_key\n",
        "  nxt_key_row = state_key[0]\n",
        "  nxt_key_col = state_key[1]\n",
        "  if action == 'up':\n",
        "    nxt_key_row -= 1\n",
        "  elif action == 'down':\n",
        "    nxt_key_row += 1\n",
        "  elif action == 'left':\n",
        "    nxt_key_col -= 1\n",
        "  elif action == 'right':\n",
        "    nxt_key_col += 1\n",
        "  if nxt_key_row >= 0 and nxt_key_row <= 3:\n",
        "    if nxt_key_col >= 0 and nxt_key_col <= 11:\n",
        "      return (nxt_key_row, nxt_key_col)\n",
        "    else:\n",
        "      return origin\n",
        "  else:\n",
        "    return origin\n",
        "\n",
        "# reward function\n",
        "def reward(next_state_key):\n",
        "    if state[next_state_key] == -1:\n",
        "        return -100\n",
        "    else:\n",
        "        return -1"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sTSJHPU8IbtD"
      },
      "source": [
        "# Q talbe intialize\n",
        "Q_table_SARSA = defaultdict(lambda : 0)\n",
        "pi_table_SARSA = defaultdict(lambda : 0)\n",
        "Q_table_Q_learning = defaultdict(lambda : 0)\n",
        "pi_table_Q_learning = defaultdict(lambda : 0)\n",
        "\n",
        "rewardSumList_SARSA = []\n",
        "rewardSumList_Q_learning = []"
      ],
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sEXi_g33IdGm"
      },
      "source": [
        "# choose action on epsilon-greedy-policy\n",
        "def chooseAction(state_key, Q_table, epsilon):\n",
        "    if np.random.uniform(0,1) <= epsilon:\n",
        "        return np.random.choice(actions)\n",
        "    else:\n",
        "        Q_up = Q_table[(state_key,'up')]\n",
        "        Q_down = Q_table[(state_key,'down')]\n",
        "        Q_left = Q_table[(state_key,'left')]\n",
        "        Q_right = Q_table[(state_key,'right')]\n",
        "        QList = [Q_up, Q_down, Q_left, Q_right]\n",
        "        ind = QList.index(max(QList))\n",
        "        return actions[ind] # actions = [\"up\", \"down\", \"left\", \"right\"]"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "faiU54cbIesX"
      },
      "source": [
        "# SARSA control\n",
        "def play_episode_SARSA(start_key, actions):\n",
        "  episode = []\n",
        "  rewardList_SARSA = []\n",
        "  state_key = start_key\n",
        "  while True:\n",
        "    if state[state_key] == -1: # if state is cliff state, break\n",
        "      #print('cliff! end game')\n",
        "      episode.append(state_key)\n",
        "      break\n",
        "    a = chooseAction(state_key, Q_table_SARSA, 0.1)\n",
        "    s_prime_key = nxtstateKey(state_key, a)\n",
        "    r = reward(s_prime_key)\n",
        "    rewardList_SARSA.append(r) # for making episode-reward graph\n",
        "    episode.append([state_key,a,r])\n",
        "    a_prime = chooseAction(s_prime_key, Q_table_SARSA, 0.1)\n",
        "    Q_table_SARSA[state_key,a] = Q_table_SARSA[state_key,a] + alpa*(r + gamma*Q_table_SARSA[s_prime_key,a_prime]-Q_table_SARSA[state_key,a])\n",
        "    state_key = s_prime_key\n",
        "    a = a_prime\n",
        "    if state_key == (3,11):\n",
        "      #print('Goal!!!')\n",
        "      episode.append(state_key)\n",
        "      break\n",
        "  #print(episode)\n",
        "  rewardSumList_SARSA.append(sum(rewardList_SARSA))\n",
        "  #print(rewardSumList_SARSA)"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qcYHcVT60pJ_"
      },
      "source": [
        "# Q-learning control\n",
        "def play_episode_Qlearning(start_key, actions):\n",
        "  episode = []\n",
        "  rewardList_Q_learning = []\n",
        "  state_key = start_key\n",
        "  while True:\n",
        "    if state[state_key] == -1:\n",
        "      #print('cliff! end game')\n",
        "      episode.append(state_key)\n",
        "      break\n",
        "    a = chooseAction(state_key, Q_table_Q_learning, 0.1)\n",
        "    s_prime_key = nxtstateKey(state_key, a)\n",
        "    r = reward(s_prime_key)\n",
        "    rewardList_Q_learning.append(r) # for making episode-reward graph\n",
        "    episode.append([state_key,a,r])\n",
        "    a_optimal = chooseAction(s_prime_key, Q_table_Q_learning, 0)\n",
        "    Q_table_Q_learning[state_key,a] = Q_table_Q_learning[state_key,a] + alpa*(r + gamma*Q_table_Q_learning[s_prime_key,a_optimal]-Q_table_Q_learning[state_key,a])\n",
        "    state_key = s_prime_key\n",
        "    if state_key == (3,11):\n",
        "      #print('Goal!!!')\n",
        "      episode.append(state_key)\n",
        "      break\n",
        "  #print(episode)\n",
        "  rewardSumList_Q_learning.append(sum(rewardList_Q_learning))\n",
        "  #print(rewardSumList_Q_learning)"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4gJfK6d_IjAk"
      },
      "source": [
        "# play episode on SARSA control\n",
        "count = 50000\n",
        "for _ in range(count):\n",
        "    play_episode_SARSA(start_key, actions)"
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4fzmKa9lJQpv"
      },
      "source": [
        "# play episode on Q-learning control\n",
        "for _ in range(count):\n",
        "    play_episode_Qlearning(start_key, actions)"
      ],
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1IWJHUwFZHit"
      },
      "source": [
        "# pi_table_SARSA update \n",
        "for i in range(4):\n",
        "  for j in range(12):\n",
        "    Q_up = Q_table_SARSA[((i,j),'up')]\n",
        "    Q_down = Q_table_SARSA[((i,j),'down')]\n",
        "    Q_left = Q_table_SARSA[((i,j),'left')]\n",
        "    Q_right = Q_table_SARSA[((i,j),'right')]\n",
        "    QList = [Q_up,Q_down,Q_left,Q_right]\n",
        "    ind = QList.index(max(QList))\n",
        "    pi_table_SARSA[(i,j)] = actions[ind] # actions = [\"up\", \"down\", \"left\", \"right\"]\n",
        "\n",
        "# pi_table_Qlearning update \n",
        "for i in range(4):\n",
        "  for j in range(12):\n",
        "    Q_up = Q_table_Q_learning[((i,j),'up')]\n",
        "    Q_down = Q_table_Q_learning[((i,j),'down')]\n",
        "    Q_left = Q_table_Q_learning[((i,j),'left')]\n",
        "    Q_right = Q_table_Q_learning[((i,j),'right')]\n",
        "    QList = [Q_up,Q_down,Q_left,Q_right]\n",
        "    ind = QList.index(max(QList))\n",
        "    pi_table_Q_learning[(i,j)] = actions[ind] # actions = [\"up\", \"down\", \"left\", \"right\"]"
      ],
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nzvMhyrYeJeE",
        "outputId": "329169d7-c94b-4d71-b6f8-019b1644d10c"
      },
      "source": [
        "# draw pi_table_SARSA on gridworld\n",
        "for i in range(4):\n",
        "  print('-------------------------------------------------------------')\n",
        "  out = '| '\n",
        "  for j in range(12):\n",
        "    if pi_table_SARSA[(i,j)] == 'up':\n",
        "      token = '↑'\n",
        "    if pi_table_SARSA[(i,j)] == 'down':\n",
        "      token = '↓'\n",
        "    if pi_table_SARSA[(i,j)] == 'right':\n",
        "      token = '→'\n",
        "    if pi_table_SARSA[(i,j)] == 'left':\n",
        "      token = '←'\n",
        "    if state[(i,j)] == -1:\n",
        "      token = '**'\n",
        "    #if (i, j) == (3,0):\n",
        "    #  token = ' S '\n",
        "    if (i, j) == (3,11):\n",
        "      token = ' G '\n",
        "    out += token + ' | '\n",
        "  print(out)\n",
        "print('-------------------------------------------------------------')"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-------------------------------------------------------------\n",
            "| → | → | → | → | → | → | → | → | → | → | → | ↓ | \n",
            "-------------------------------------------------------------\n",
            "| ↑ | → | ↑ | ↑ | ↑ | → | → | → | → | → | → | ↓ | \n",
            "-------------------------------------------------------------\n",
            "| ↑ | ↑ | ↑ | ↑ | ↑ | ↑ | ↑ | ↑ | ↑ | ↑ | → | ↓ | \n",
            "-------------------------------------------------------------\n",
            "| ↑ | ** | ** | ** | ** | ** | ** | ** | ** | ** | ** |  G  | \n",
            "-------------------------------------------------------------\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MBRjlY8tAldJ",
        "outputId": "af1585f9-86be-410c-d15e-620019136d61"
      },
      "source": [
        "# draw pi_table_Qlearning on gridworld\n",
        "for i in range(4):\n",
        "  print('-------------------------------------------------------------')\n",
        "  out = '| '\n",
        "  for j in range(12):\n",
        "    if pi_table_Q_learning[(i,j)] == 'up':\n",
        "      token = '↑'\n",
        "    if pi_table_Q_learning[(i,j)] == 'down':\n",
        "      token = '↓'\n",
        "    if pi_table_Q_learning[(i,j)] == 'right':\n",
        "      token = '→'\n",
        "    if pi_table_Q_learning[(i,j)] == 'left':\n",
        "      token = '←'\n",
        "    if state[(i,j)] == -1:\n",
        "      token = '**'\n",
        "    #if (i, j) == (3,0):\n",
        "      #token = ' S '\n",
        "    if (i, j) == (3,11):\n",
        "      token = ' G '\n",
        "    out += token + ' | '\n",
        "  print(out)\n",
        "print('-------------------------------------------------------------')"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-------------------------------------------------------------\n",
            "| ↓ | → | → | → | ↓ | → | → | ↓ | → | → | ↓ | ↓ | \n",
            "-------------------------------------------------------------\n",
            "| ↓ | ↓ | ↓ | ↓ | ↓ | ↓ | ↓ | ↓ | ↓ | ↓ | ↓ | ↓ | \n",
            "-------------------------------------------------------------\n",
            "| → | → | → | → | → | → | → | → | → | → | → | ↓ | \n",
            "-------------------------------------------------------------\n",
            "| ↑ | ** | ** | ** | ** | ** | ** | ** | ** | ** | ** |  G  | \n",
            "-------------------------------------------------------------\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 288
        },
        "id": "vlUFyKsv7jWq",
        "outputId": "2dd68077-bb78-4407-bca4-9f9719b26bfa"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "fig = plt.figure()\n",
        "episode_count = []\n",
        "for i in range(count):\n",
        "    episode_count.append(i+1)\n",
        "plt.plot(episode_count,rewardSumList_SARSA, label='SARSA')\n",
        "plt.plot(episode_count,rewardSumList_Q_learning, label='Q-learning')\n",
        "plt.legend()\n",
        "plt.xlim(9900,10000)"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(9900.0, 10000.0)"
            ]
          },
          "metadata": {},
          "execution_count": 38
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}