001 From Scratch AI Balancing Act in 50 Lines of Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Week one - https://github.com/andri27-ts/60_Days_RL_Challenge#week-1---introduction\n",
    "\n",
    "Please watch the videos of week one before see the code\n",
    "\n",
    "My code follow this blog https://towardsdatascience.com/from-scratch-ai-balancing-act-in-50-lines-of-python-7ea67ef717\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### To install environment\n",
    "pip install gym "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lecture:\n",
    " - https://www.youtube.com/watch?v=JgvyzIkgxF0\n",
    " - https://www.youtube.com/watch?v=Q4kF8sfggoI&index=1&list=PLkFD6_40KJIznC9CDbVTjAF2oyt8_VAe3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/user/.conda/envs/RF/lib/python3.6/site-packages/gym/logger.py:30: UserWarning: \u001b[33mWARN: You are calling 'step()' even though this environment has already returned done = True. You should always call 'reset()' once you receive 'done = True' -- any further steps are undefined behavior.\u001b[0m\n",
      "  warnings.warn(colorize('%s: %s'%('WARN', msg % args), 'yellow'))\n"
     ]
    }
   ],
   "source": [
    "env = gym.make('CartPole-v0')\n",
    "env.reset()\n",
    "for _ in range(200):\n",
    "    env.render()\n",
    "    env.step(env.action_space.sample()) # take a random action\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Read time:\n",
    "https://gym.openai.com/docs/\n",
    "\n",
    "Key words: Observations, Action Space\n",
    "\n",
    "State: A state is what the game looks like at the moment. We typically deal with numerical representation of games.\n",
    "\n",
    "Policy: A policy is a function that can take the state of the game (ex. position of board pieces, or where the cart and pole are) and output the action the agent should take in the position (ex. move the knight, or push the cart to the left)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode finished after 34 timesteps\n",
      "Episode finished after 33 timesteps\n",
      "Episode finished after 13 timesteps\n",
      "Episode finished after 10 timesteps\n",
      "Episode finished after 25 timesteps\n"
     ]
    }
   ],
   "source": [
    "env = gym.make('CartPole-v0')\n",
    "for i_episode in range(5):\n",
    "    observation = env.reset()\n",
    "    for t in range(1000):\n",
    "        env.render()\n",
    "        # take random action\n",
    "        action = env.action_space.sample()\n",
    "        observation, reward, done, info = env.step(action)\n",
    "        if done:\n",
    "            print(\"Episode finished after {} timesteps\".format(t+1))\n",
    "            break\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we only get less than 100 steps if we use random action."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Spaces: action space and observation space\n",
    "In the examples above, we’ve been sampling random actions from the environment’s action space.\n",
    "\n",
    "But what actually are those actions? Every environment comes with an action_space and an observation_space. \n",
    "\n",
    "These attributes are of type Space, and they describe the format of valid actions and observations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We have Discrete(2) actions: pushing the cart left or right\n",
      "State have Box(4,) values: cart_position, cart_velocity, pole_angle, pole_velocity\n"
     ]
    }
   ],
   "source": [
    "env = gym.make('CartPole-v0', )\n",
    "print(f\"We have {env.action_space} actions: pushing the cart left or right\")\n",
    "print(f\"State have {env.observation_space} values: cart_position, cart_velocity, pole_angle, pole_velocity\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4.8000002e+00 3.4028235e+38 4.1887903e-01 3.4028235e+38]\n",
      "[-4.8000002e+00 -3.4028235e+38 -4.1887903e-01 -3.4028235e+38]\n"
     ]
    }
   ],
   "source": [
    "# and limit of space:\n",
    "print(env.observation_space.high)\n",
    "print(env.observation_space.low)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the case of cart pole, our state is composed of 4 numbers: \n",
    " - the position of the cart.\n",
    " - the speed of the cart.\n",
    " - the position of the pole (as an angle).\n",
    " - the angular velocity of the pole. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_state(state):\n",
    "    [cart_position, cart_velocity, pole_angle, pole_velocity] = state\n",
    "    print(f\"cart_position: {cart_position}, \\ncart_velocity: {cart_velocity} \\npole_angle {pole_angle}, \\npole_velocity {pole_velocity}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cart_position: 0.04359785474820241, \n",
      "cart_velocity: 0.018802304126176964 \n",
      "pole_angle -0.03908218937460955, \n",
      "pole_velocity 0.033135432915376684\n"
     ]
    }
   ],
   "source": [
    "state = env.reset()\n",
    "print_state(state)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Policy():\n",
    "    def __init__(self, env):\n",
    "        self.action_space = env.action_space\n",
    "        self.action_names = ['left', 'right']\n",
    "    def get_next_action(self, state):\n",
    "        pass\n",
    "    def get_name(self, action):\n",
    "        return self.action_names[action]\n",
    "    def print_state(self, state):\n",
    "        [cart_position, cart_velocity, pole_angle, pole_velocity] = state\n",
    "        print(f\"cart_position: {cart_position}, \\ncart_velocity: {cart_velocity} \\npole_angle {pole_angle}, \\npole_velocity {pole_velocity}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Create a random policy:\n",
    "class RandomPolicy(Policy):\n",
    "    def get_next_action(self, state):\n",
    "        action = self.action_space.sample()\n",
    "        return action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "env = gym.make('CartPole-v0')\n",
    "random_policy = RandomPolicy(env)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cart_position: -0.040489677292753594, \n",
      "cart_velocity: -0.0017911505501419095 \n",
      "pole_angle -0.01906615163274733, \n",
      "pole_velocity 0.013454913819935799\n",
      "right\n",
      "\n",
      "==========\n",
      "\n",
      "cart_position: 0.01792027537687163, \n",
      "cart_velocity: 0.049595158271136364 \n",
      "pole_angle -0.023119581956618285, \n",
      "pole_velocity -0.014386709235517173\n",
      "right\n",
      "\n",
      "==========\n",
      "\n",
      "cart_position: 0.006687556486496507, \n",
      "cart_velocity: 0.003749312349641952 \n",
      "pole_angle 0.04117240419634395, \n",
      "pole_velocity 0.015855296707534258\n",
      "right\n",
      "\n",
      "==========\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    observation = env.reset()\n",
    "    action = random_policy.get_next_action(observation)\n",
    "    random_policy.print_state(observation)\n",
    "    print(random_policy.get_name(action))\n",
    "    print('\\n==========\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode finished after 18 timesteps\n",
      "Episode finished after 26 timesteps\n",
      "Episode finished after 36 timesteps\n",
      "Episode finished after 13 timesteps\n",
      "Episode finished after 30 timesteps\n"
     ]
    }
   ],
   "source": [
    "for i_episode in range(5):\n",
    "    observation = env.reset()\n",
    "    for t in range(1000):\n",
    "        env.render()\n",
    "        # take random action\n",
    "        action = random_policy.get_next_action(observation)\n",
    "        observation, reward, done, info = env.step(action)\n",
    "        if done:\n",
    "            print(\"Episode finished after {} timesteps\".format(t+1))\n",
    "            break\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# all fail after less than 50 steps!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.PngImagePlugin.PngImageFile image mode=RGBA size=778x584 at 0x7FD3D20CC898>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image.open(\"./sample_state.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now intuitively, we’ll want to straighten the pole back up by pushing the cart to the right. \n",
    "\n",
    "I’ve taken a good policy from one of my training runs and \n",
    "\n",
    "its policy array reads: [-0.116, 0.332, 0.207 0.352]. \n",
    "\n",
    "Let’s do the math real quick by hand and see what this policy will output as an action for this state.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Create a statistic policy:\n",
    "import numpy as np\n",
    "class StatisticPolicy(Policy):\n",
    "    def __init__(self, env, policy):\n",
    "        self.action_space = env.action_space\n",
    "        self.policy = policy\n",
    "        self.action_names = ['left', 'right']\n",
    "    \n",
    "    def update_policy(self, policy):\n",
    "        self.policy = policy\n",
    "        \n",
    "    def get_next_action(self, state):\n",
    "        action = np.dot(state, self.policy)\n",
    "        if action < 0:\n",
    "            return 0 # pushing to the left\n",
    "        else:\n",
    "            return 1 # pushing to the right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "statistic_policy = StatisticPolicy(env, np.array([-0.116, 0.332, 0.207, 0.352]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cart_position: -0.015106649888446198, \n",
      "cart_velocity: -0.03757811824984077 \n",
      "pole_angle 0.02238285735765136, \n",
      "pole_velocity 0.045793804614445655\n",
      "right\n",
      "\n",
      "==========\n",
      "\n",
      "cart_position: -0.0011923728953741053, \n",
      "cart_velocity: 0.035082233652551295 \n",
      "pole_angle 0.01079520829672189, \n",
      "pole_velocity -0.016994300293552665\n",
      "right\n",
      "\n",
      "==========\n",
      "\n",
      "cart_position: 0.013754574446472365, \n",
      "cart_velocity: -0.01241078533170329 \n",
      "pole_angle -0.038683524093090664, \n",
      "pole_velocity 0.033189973361485464\n",
      "left\n",
      "\n",
      "==========\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    observation = env.reset()\n",
    "    action = statistic_policy.get_next_action(observation)\n",
    "    statistic_policy.print_state(observation)\n",
    "    print(statistic_policy.get_name(action))\n",
    "    print('\\n==========\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode finished after 200 timesteps\n",
      "Episode finished after 200 timesteps\n",
      "Episode finished after 200 timesteps\n"
     ]
    }
   ],
   "source": [
    "for i_episode in range(3):\n",
    "    observation = env.reset()\n",
    "    for t in range(10000):\n",
    "        env.render()\n",
    "        # take random action\n",
    "        action = statistic_policy.get_next_action(observation)\n",
    "        observation, reward, done, info = env.step(action)\n",
    "#         print(done, reward, observation)\n",
    "        if done:\n",
    "            print(\"Episode finished after {} timesteps\".format(t+1))\n",
    "            break\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The max_episode_steps only 200 steps. We can only play 200 steps for each game."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode finished after 500 timesteps\n",
      "Episode finished after 500 timesteps\n",
      "Episode finished after 500 timesteps\n"
     ]
    }
   ],
   "source": [
    "# let set max episode steps = 500\n",
    "env._max_episode_steps = 500\n",
    "\n",
    "for i_episode in range(3):\n",
    "    observation = env.reset()\n",
    "    for t in range(10000):\n",
    "        env.render()\n",
    "        action = statistic_policy.get_next_action(observation)\n",
    "        observation, reward, done, info = env.step(action)\n",
    "#         print(done, reward, observation)\n",
    "        if done:\n",
    "            print(\"Episode finished after {} timesteps\".format(t+1))\n",
    "            break\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let make the code easy to read:\n",
    "def play(env, policy):\n",
    "    for i_episode in range(3):\n",
    "        observation = env.reset()\n",
    "        for t in range(10000):\n",
    "            env.render()\n",
    "            action = policy.get_next_action(observation)\n",
    "            observation, reward, done, info = env.step(action)\n",
    "    #         print(done, reward, observation)\n",
    "            if done:\n",
    "                print(\"Episode finished after {} timesteps\".format(t+1))\n",
    "                break\n",
    "    env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode finished after 500 timesteps\n",
      "Episode finished after 500 timesteps\n",
      "Episode finished after 500 timesteps\n"
     ]
    }
   ],
   "source": [
    "env._max_episode_steps = 500\n",
    "play(env, statistic_policy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Policy Search\n",
    "How to find good policy search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4.8000002e+00 3.4028235e+38 4.1887903e-01 3.4028235e+38]\n",
      "[-4.8000002e+00 -3.4028235e+38 -4.1887903e-01 -3.4028235e+38]\n"
     ]
    }
   ],
   "source": [
    "print(env.observation_space.high)\n",
    "print(env.observation_space.low)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cart_position: 0.019116420545397472, \n",
    "# cart_velocity: -0.009272760733395932 \n",
    "# pole_angle 0.03902117151277583, \n",
    "# pole_velocity -0.008606676659720348"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can check all posible policy\n",
    "# cart_position in range [-4.8, 4.8]\n",
    "# cart_velocity in range [-3, 3]\n",
    "# pole_angle in range [-.4, .4]\n",
    "# pole_velocity in range [-4, 4]\n",
    "def create_range(min_value, max_value, step = 1.0):\n",
    "    return np.arange(min_value, max_value, step)\n",
    "\n",
    "cart_positions = create_range(-3, 3)\n",
    "cart_velocities = create_range(-3, 3)\n",
    "pole_angles = create_range(-3, 3)\n",
    "pole_velocities = create_range(-3, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play(env, policy, n=10, render=True):\n",
    "    scores = []\n",
    "    for i_episode in range(n):\n",
    "        observation = env.reset()\n",
    "        for t in range(1000):\n",
    "            if render:\n",
    "                env.render()\n",
    "            action = policy.get_next_action(observation)\n",
    "            observation, reward, done, info = env.step(action)\n",
    "            if done:\n",
    "                scores.append(t)\n",
    "                break\n",
    "    env.close()\n",
    "    return min(scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "play(env, RandomPolicy(env))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "def validate_policy(env, cart_positions, cart_velocities, pole_angles, pole_velocities):\n",
    "    statistic_policy = StatisticPolicy(env, np.array([0,0,0,0]))\n",
    "    count = 0\n",
    "    result = []\n",
    "    for cart_position in cart_positions:\n",
    "        for cart_velocity in cart_velocities:\n",
    "            for pole_angle in pole_angles:\n",
    "                for pole_velocity in pole_velocities:\n",
    "                    policy_array = np.array([cart_position, cart_velocity, pole_angle, pole_velocity])\n",
    "                    statistic_policy.update_policy(policy_array)\n",
    "                    score = play(env, statistic_policy, render=False)\n",
    "                    result.append((score, policy_array))\n",
    "                    count = count + 1\n",
    "    print(count)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1296\n"
     ]
    }
   ],
   "source": [
    "cart_positions = create_range(-3, 3)\n",
    "cart_velocities = create_range(-3, 3)\n",
    "pole_angles = create_range(-3, 3)\n",
    "pole_velocities = create_range(-3, 3)\n",
    "result = validate_policy(env, cart_positions, cart_velocities, pole_angles, pole_velocities)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21 14 10\n"
     ]
    }
   ],
   "source": [
    "# check number of policy > 100, > 200:\n",
    "print(len([score for score, _ in result if score > 200]),len([score for score, _ in result if score > 300]), len([score for score, _ in result if score > 490])) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "499"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max([score for score, _ in result])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let do some statistic on the best policy:\n",
    "best_policy_array = [policy_array for score, policy_array in result if score > 300]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "363"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check some best_policy_array:\n",
    "statistic_policy.update_policy(best_policy_array[1])\n",
    "play(env, statistic_policy, render=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.stack(best_policy_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([-1.,  0.,  0.,  1.]), array([1., 2., 2., 2.]))"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mins, maxs = t.min(axis=0), t.max(axis=0)\n",
    "mins, maxs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "positions = [create_range(i,j,.2) for i,j in zip(mins,maxs)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([-1.00000000e+00, -8.00000000e-01, -6.00000000e-01, -4.00000000e-01,\n",
       "        -2.00000000e-01, -2.22044605e-16,  2.00000000e-01,  4.00000000e-01,\n",
       "         6.00000000e-01,  8.00000000e-01]),\n",
       " array([0. , 0.2, 0.4, 0.6, 0.8, 1. , 1.2, 1.4, 1.6, 1.8]),\n",
       " array([0. , 0.2, 0.4, 0.6, 0.8, 1. , 1.2, 1.4, 1.6, 1.8]),\n",
       " array([1. , 1.2, 1.4, 1.6, 1.8])]"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "positions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5000\n"
     ]
    }
   ],
   "source": [
    "result = validate_policy(env, *positions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2776 1958 1232\n"
     ]
    }
   ],
   "source": [
    "# check number of policy > 100, > 200:\n",
    "print(len([score for score, _ in result if score > 200]),len([score for score, _ in result if score > 300]), len([score for score, _ in result if score > 490])) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max score 499\n"
     ]
    }
   ],
   "source": [
    "# only choose the policies have score > 400:\n",
    "print('max score', max([score for score, _ in result]))\n",
    "best_policy_array = [policy_array for score, policy_array in result if score > 480]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "441"
      ]
     },
     "execution_count": 245,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check some best_policy_array:\n",
    "statistic_policy.update_policy(best_policy_array[2])\n",
    "play(env, statistic_policy, render=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "139"
      ]
     },
     "execution_count": 246,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(best_policy_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We have 139 promised policies, we will run test on it 100 times and accept that policy if all scores > 499.\n",
    "accepted_array = []\n",
    "for array in best_policy_array:\n",
    "    statistic_policy.update_policy(array)\n",
    "    min_score = play(env, statistic_policy, n=100, render=False)\n",
    "    if min_score == 499:\n",
    "        accepted_array.append(array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 255,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(accepted_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "499"
      ]
     },
     "execution_count": 265,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "statistic_policy.update_policy(accepted_array[random.randint(0, len(accepted_array))])\n",
    "play(env, statistic_policy, n=100, render=False)"
   ]
  }
 ],
 "metadata": {
  "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}