Mod5-2-ML-RL.ipynb

{"nbformat":4,"nbformat_minor":0,"metadata":{"celltoolbar":"Slideshow","colab":{"name":"Mod5-2-ML-RL.ipynb","provenance":[],"collapsed_sections":[]},"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.7"}},"cells":[{"cell_type":"markdown","metadata":{"id":"-7Ss-KkDBzMu"},"source":["\n","# <font color=#770000>ICPE 639 Introduction to Machine Learning </font>\n","\n","## ------ With Energy Applications\n","\n","<p> &#169; 2021: Xiaoning Qian </p>\n","\n","[Homepage](http://xqian37.github.io/)\n","\n","**<font color=blue>[Note]</font>** This is currently a work in progress, will be updated as the material is tested in the class room.\n","\n","All material open source under a Creative Commons license and free for use in non-commercial applications.\n","\n","Source material used under the Creative Commons Attribution-NonCommercial 3.0 Unported License. To view a copy of this license, visit http://creativecommons.org/licenses/by-nc/3.0/ or send a letter to Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.\n"]},{"cell_type":"markdown","metadata":{"id":"BSpTU7H9DWl8"},"source":["# Reinforcement Learning\n","\n","This section will provide a **very basic** introduction to Reinforcement Learning (RL): \n","\n","- [1 Markov Decision Process](#1-Markov-Decision-Process)\n","- [2 Q Learning](#2-Q-Learning)\n","- [3 Deep RL](#3-Deep-RL)\n","- [4 Hands-on Exercise](#4-Exercise)\n","- [Reference](#Reference)\n","\n","**<font color=blue>[Note]</font>**: Most of the materials here were based on the Microsoft free course: https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/README.md and https://towardsdatascience.com/understanding-the-markov-decision-process-mdp-8f838510f150"]},{"cell_type":"markdown","metadata":{"id":"8ifbVhVQe9Kz"},"source":["## 1 Markov Decision Process\n","\n","RL is to make the *optimal* decision, with model or model-free settings considering the underlying system, to achieve the maximum **reward**. \n","\n","### Basics\n","\n","RL is to make the *optimal* decision, with model or in a model-free setting for the underlying system, to achieve the maximum **reward**. For model-based decision making (control theory), Markov Decision Process (MDP) can serve as the foundation. The underlying dynamic model of MDP can be related to the state-space model that we just introduced. \n","\n","MDP often involves the following critical components: \n","1. **State** in a state space $\\mathcal{X}$;\n","2. **Action** in the action space $\\mathcal{A}$;\n","3. **Transition** $\\mathbf{P}$ governing the state dynamics (state-space models): $\\mathbf{P}: \\mathcal{X} \\times \\mathcal{A} \\rightarrow \\mathcal{X}$ (deterministic) or $\\mathbf{P}: \\mathcal{X} \\times \\mathcal{A} \\times \\mathcal{X} \\rightarrow [0, 1]$ (probabilistic);\n","4. **Reward** $\\mathbf{R}$ modeling the expected reward to take a certain action to reach different states: $\\mathbf{R}: \\mathcal{X} \\times \\mathcal{A} \\times \\mathcal{X} \\rightarrow \\mathbb{R}$. \n","\n","With these four elements, we can model how an **agent** may interact with the **environment** based on $\\mathbf{P}$. The goal of RL is to derive a good **policy** to achieve the best reward based on $\\mathbf{R}$. If we have the model $\\mathbf{P}$ and $\\mathbf{R}$, we are with model-based RL. Otherwise, we are doing model-free RL, a famous one of which is **Q-learning**. \n","\n","\n"]},{"cell_type":"markdown","metadata":{"id":"l8ovH9wOc1Yl"},"source":["\n","<img src=\"https://miro.medium.com/max/6000/1*p4JW6ibYcdmaeXVB_klivA.png\" alt=\"MDP1\">\n","\n","<center>A Schematic for an artificial MDP</center>\n","\n","<img src=\"https://miro.medium.com/max/1750/1*QLeo3MikUeGvNyVjl5mqoA.png\" alt=\"MDP2\">\n","\n","<center>A Schematic for a Robot MDP</center>"]},{"cell_type":"markdown","metadata":{"id":"ZmnfUeC3fNVv"},"source":["\n","### Markov Property\n","\n","MDP can be considered as a **Markov Chain** with actions and assigned rewards. The introductory materials of MDP often starts with the finite state space and action space. Given the current state, the future is often assumed to be **conditionally independent** with the past, known as **Markov property**: \n","$$\\mathbf{P}(x_{t+1} | x_t, a_t; \\mbox{ the past state-action history }) = \\mathbf{P}(x_{t+1} | x_{t}, a_t).$$\n","\n","\n"]},{"cell_type":"markdown","metadata":{"id":"kef9GIl2RLUg"},"source":["### MDP problem formulations\n","\n","The goal is to derive a **control policy** to specific which action to take given the state at specific time: \n","$$\\pi(a|x; t) = P(A_t = a | X_t = x). $$\n","\n","The control policy can be either **deterministic** or **probabilistic**. If the policy is not dependent on time, $\\pi(a|x; t) =\\pi(a |x)$, then it is **stationary**, which is often the case in many applications.  \n"]},{"cell_type":"markdown","metadata":{"id":"N69yxdSNlBaM"},"source":["### Value Iteration\n","\n","#### Policy Value: \n","\n","The **value** of a given policy $\\pi(a|x)$ at $x$ is the **expected cumulative rewards** (often discounted) with the **discount factor** $\\gamma \\in (0, 1)$: \n","$$V(x) = \\mathbb{E}_P[\\mathbf{R}(x_0=x, a_0, x_1) + \\gamma \\mathbf{R}(x_1, a_1, x_2) + \\ldots + \\gamma^t \\mathbf{R}(x_t, a_t, x_{t+1}) + \\ldots|\\pi]$$\n","\n","By divide and conquer (an important trick for **dynamic programming**): \n","$$V(x) = \\mathbb{E}_{x_1}[\\mathbb{E}_P[\\mathbf{R}(x_0=x, a_0, x_1) + \\gamma V(x_1)]]$$\n","\n","#### Optimal value and optimal action: \n","\n","The logic of dynamic programming: To achieve the optimality of the whole sequence, each sub-sequence shall be also optimal. This leads to the famous **Bellman Optimality Equation**: \n","\n","$$V_{opt}(x) = \\max_{a\\in\\mathcal{A}}{\\sum_{x_1} \\mathbf{P}(x_1|x_0=x, a_0=a)(\\mathbf{R}(x_0=x, a_0, x_1) + \\gamma V_{opt}(x_1) )}$$\n","\n","Assume that the iteration converges to a **stationary** policy (discounting). This immediate gives the **value iteration algorithm**: \n","\n","$$V_{k+1} = \\max_{a\\in\\mathcal{A}}{\\sum_{x'} \\mathbf{P}(x'|x, a)(\\mathbf{R}(x, a, x') + \\gamma V_{k}(x') )}.$$\n","\n","$V_{k} \\rightarrow V_{opt}$ for stationary control policies. "]},{"cell_type":"markdown","metadata":{"id":"3nFQHQsBR5LQ"},"source":["### State-Action (Q) Value\n","\n","The Q value of a given policy $\\pi(a|x)$ at $x$ with action $a$ is the expected cumulative rewards with the discount factor $\\gamma$:\n","$$Q(x, a) = \\mathbb{E}_{x_1}[\\mathbb{E}_P[\\mathbf{R}(x_0=x, a_0=a, x_1) + \\gamma \\max_{a_1} Q(x_1, a_1)]].$$\n","\n","It has the same recursive structure. \n","\n","### Q value iteration algorithm: \n","\n","We can now derive the **optimal policy**: \n","$$\\pi_{opt}(a|x) = \\arg\\max_a Q_{opt}(x,a),$$\n","where $Q_{opt}(x,a) = \\mathbf{R}'(x_0=x, a_0=a) + \\gamma \\sum_{x_1} \\mathbf{P}(x_1|x,a) V_{opt}(x_1)$ and $V_{opt}(x_1)$ can be solved: \n","$$V_{opt}(x_1) = \\max_{a} Q(x_1, a)$$\n","as done by value iteration. \n","\n","And \n","$$Q_{k+1}(x,a) = \\sum_{x'} \\mathbf{P}(x'|x, a)(\\mathbf{R}(x, a, x') + \\gamma \\max_{a_1} Q_k(x_1, a_1))$$\n","(Q-value iteraction)."]},{"cell_type":"markdown","metadata":{"id":"3Bq7RFmJVCgZ"},"source":["### Policy Iteration\n","\n","We can also derive the **policy iteration** algorithm with the same dynamic programming trick: \n","\n","$$\\pi_k(a|x) = \\arg\\max_a{\\sum_{x'} \\mathbf{P}(x'|x, a)(\\mathbf{R}(x, a, x') + \\gamma V_{\\pi_k}(x') )},$$\n","where $V_{\\pi_k}(x')$ is evaluated value based on the previous policy. "]},{"cell_type":"markdown","metadata":{"id":"3Zu-Sv_RWD8k"},"source":["## 2 Q Learning\n","\n","Q Learning is a model-free RL method when we do not have the model for transition $\\mathbf{P}$ or reward $\\mathbf{R}$. Note that to be exact, RL often referrs to the model-free situations where you have to derive the policy based on the interaction between the agent and environment through experience/observations, *in an end-to-end fashion*. The policy $\\pi(a|x)$ is learned only driven by the observed reward $r(x,a)$, for example as \"relayed experience\". \n","\n","$$ \\mathcal{D} = \\{(x, a, r, x')_t\\}_{t=0}^{T} \\rightarrow Q_{opt}(x, a) \\rightarrow \\pi_{opt}(a|x) $$"]},{"cell_type":"markdown","metadata":{"id":"BuCO0-82xECQ"},"source":["### Q Learning Algorithm\n","\n","1. Initialize Q-Table **$Q$** with equal numbers for all states and actions\n","2. Set **learning rate** $\\alpha\\leftarrow 1$\n","3. Repeat simulation many times\n","\n","   A. Start at random position\n","\n","   B. Repeat\n","\n","      1. Select an action $a$ at state $x$\n","      2. Exectute action by moving to a new state $x'$\n","      3. If we encounter end-of-game condition, or total reward is too small - exit simulation\n","      4. Compute reward $r$ at the new state\n","      5. Update Q-Function according to Bellman equation: $$Q(x,a)\\leftarrow (1-\\alpha)Q(x,a)+\\alpha(r+\\gamma\\max_{a'}Q(x',a'))$$\n","      6. $x\\leftarrow x'$\n","      7. Update total reward and decrease $\\alpha$."]},{"cell_type":"markdown","metadata":{"id":"1B7xelo97ZtL"},"source":["Check the above updating equation: \n","$$Q(x,a) \\leftarrow Q(x,a) + \\alpha(r+\\gamma\\max_{a'}Q(x',a') - Q(x,a))$$. \n","\n","Similarity to what we have seen for other gradient descent updates. "]},{"cell_type":"markdown","metadata":{"id":"N_bCbsAyyf-h"},"source":["### Exploration vs. Exploitation\n","\n","At the step **3.B.2**, if random policy is adopted, it is simply **exploring** the state and action space randomly, which can be time-consuming to converge to the optimal policy. \n","\n","**$\\epsilon$-greedy policy**: With $1-\\epsilon$ probabilty to take the action that gives the best Q value (**exploitation**). \n"]},{"cell_type":"markdown","metadata":{"id":"wxt1TzsmyzdI"},"source":["### Temporal Difference Learning\n","\n","Similarly, from the value iteration algorithm, we can derive the corresponding Temporal Difference Learning (TD Learning): \n","\n","$$V(x)\\leftarrow (1-\\alpha)V(x)+\\alpha(r+\\gamma V(x'))$$\n","\n","This is simply updating the running average (**incremental learning**). "]},{"cell_type":"markdown","metadata":{"id":"8u9tBCwj1z_k"},"source":["Please check the following links for related examples: \n","\n","https://github.com/ageron/handson-ml/blob/master/16_reinforcement_learning.ipynb\n","\n","https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/solution/notebook.ipynb"]},{"cell_type":"markdown","metadata":{"id":"hJlgGeXp3Joo"},"source":["### Q Learning with Function Approximation\n","\n","Instead of estimating Q value based on running average as above, it may be beneficial to have a model or function to **approximate** the Q value so that we may further improve the convergence properties if we can quickly learn a reasonably good function approximation: \n","\n","$$Q(x, a) \\leftarrow \\tilde{Q}(x, a; \\theta)$$\n","\n","In the above algorithm, instead of directly estimating $Q$, we can update the model parameter $\\theta$ (related to **SGD**): \n","\n","$$\\theta \\leftarrow \\theta + \\alpha_t (r_t +\\gamma \\max_{a'}\\tilde{Q}(x',a'; \\theta) - \\tilde{Q}(x,a; \\theta) )\\nabla_\\theta \\tilde{Q}(x, a; \\theta) $$\n","\n","Clearly, different function approximation can be adopted here as in other machine learning problems. This leads to the recent development of **Deep RL**. "]},{"cell_type":"markdown","metadata":{"id":"i0azZyhR-Nqi"},"source":["### Policy Gradient\n","\n","Another branch is to directly approximate the policy and learn it end-to-end: \n","$$\\pi(a|x) \\leftarrow \\tilde{\\pi}(a|x; \\theta)$$\n","\n","We will not discuss here this in detail. One of important challenges to address is to derive good gradient estimate of $\\nabla_\\theta \\tilde{\\pi}(a|x; \\theta)$. One of famous estimation method is **REINFORCE**. There have been many new methods to improve policy gradient by either better modeling $\\tilde{\\pi}(a|x; \\theta)$ or better gradient estimates. "]},{"cell_type":"markdown","metadata":{"id":"p8pug_cL5cx1"},"source":["## 3 Deep Q Learning\n","\n","<img src=\"https://pylessons.com/static/images/Reinforcement-learning/03_CartPole-reinforcement-learning/Dueling-Q-architecture.jpg\" alt=\"DQL\" size=500>\n","\n","<center>A Schematic for deep Q learning</center>\n","\n","\n","<img src=\"https://developer.ibm.com/developer/default/articles/machine-learning-and-gaming/images/Figure5.png\" alt=\"DQL\" size=500>\n","\n","<center>A Schematic for deep Q learning for policy gradient in Gaming </center>\n"]},{"cell_type":"markdown","metadata":{"id":"Q6kdk2nw6Qh-"},"source":["Note that once the approximating neural network, MLP, CNN, RNN, or GNN based on the state and action space, is specified, the learning is the same as all the other machine learning problems. \n","\n","Here, also note that we are not restricted ourselves to finite state or action space any more!\n","\n","There have been also many challenges to theoretically analyze DQN performances and empirically further improve DQN. Two main issues with vanilla DQN is the **bias** problem of overestimating Q values in noisy environment and the **moving target** problem due to using the same DQN to evaluate and choose actions. There have been recent efforts to address these problems, including **Prioritized experience replay** and **dueling/double DQN**, etc. \n","\n","\n","More tutorials can be found at: \n","\n","https://github.com/pythonlessons/Reinforcement_Learning"]},{"cell_type":"markdown","metadata":{"id":"0OFF0khjf_Im"},"source":["## 4 Hands-on Exercise: Lunar Lander V2\n","We use an OpenAI Gym's example [LunarLander-v2](https://gym.openai.com/envs/LunarLander-v2/) as the environments for the DQN algorithm. [Shiva Verma's code](https://github.com/shivaverma/OpenAIGym/blob/master/lunar-lander/discrete/lunar_lander.py) is used for the following implementation. \n","\n","<img src=\"https://miro.medium.com/max/1346/1*i7lxpgt2K3Q8lgEPJu3_xA.png\" alt=\"DQL\" size=500>\n","<center>A Schematic for LunarLander-v2</center>\n","\n","LunarLander-v2 describes a qeustion that we need to control a lunar lander to land on a specific landing position. The specific settings for the problem are:\n","\n","The action space consists of four actions: 0-do nothing; 1-Fire left orientation engine, 2-Fire down main engine, and 3-Fire right orientation engine.\n","\n","Landing pad is always at coordinates (0,0). Coordinates are the first two numbers in state vector.\n","\n","Reward for moving from the top of the screen to landing pad and zero speed is about 100..140 points. If lander moves away from landing pad it loses reward back. \n","\n","Episode finishes if the lander crashes or comes to rest, receiving additional -100 or +100 points. Each leg ground contact is +10. Firing main engine is -0.3 points each frame. Solved is 200 points. Landing outside landing pad is possible. Fuel is infinite, so an agent can learn to fly and then land on its first attempt."]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"zx6YeA5qjZti","executionInfo":{"status":"ok","timestamp":1631919386093,"user_tz":300,"elapsed":12180,"user":{"displayName":"Ziyu Xiang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"09056639542636885950"}},"outputId":"9dc14a70-f902-4504-b544-9d54d37b1846"},"source":["# Install the environments\n","!apt update\n","!apt install xvfb\n","!pip install pyvirtualdisplay\n","!pip install ribs[all] gym~=0.17.0 Box2D~=2.3.10 tqdm\n","\n","# Start Xvfb and set \"DISPLAY\" environment properly.\n","import pyvirtualdisplay\n","d = pyvirtualdisplay.Display()\n","d.start() "],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Hit:1 https://cloud.r-project.org/bin/linux/ubuntu bionic-cran40/ InRelease\n","Ign:2 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  InRelease\n","Hit:3 http://security.ubuntu.com/ubuntu bionic-security InRelease\n","Ign:4 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  InRelease\n","Hit:5 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  Release\n","Hit:6 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  Release\n","Hit:7 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic InRelease\n","Hit:8 http://archive.ubuntu.com/ubuntu bionic InRelease\n","Hit:9 http://archive.ubuntu.com/ubuntu bionic-updates InRelease\n","Hit:11 http://ppa.launchpad.net/cran/libgit2/ubuntu bionic InRelease\n","Hit:12 http://archive.ubuntu.com/ubuntu bionic-backports InRelease\n","Hit:14 http://ppa.launchpad.net/deadsnakes/ppa/ubuntu bionic InRelease\n","Hit:15 http://ppa.launchpad.net/graphics-drivers/ppa/ubuntu bionic InRelease\n","Reading package lists... Done\n","Building dependency tree       \n","Reading state information... Done\n","52 packages can be upgraded. Run 'apt list --upgradable' to see them.\n","Reading package lists... Done\n","Building dependency tree       \n","Reading state information... Done\n","xvfb is already the newest version (2:1.19.6-1ubuntu4.9).\n","0 upgraded, 0 newly installed, 0 to remove and 52 not upgraded.\n","Requirement already satisfied: pyvirtualdisplay in /usr/local/lib/python3.7/dist-packages (2.2)\n","Requirement already satisfied: EasyProcess in /usr/local/lib/python3.7/dist-packages (from pyvirtualdisplay) (0.3)\n","Requirement already satisfied: ribs[all] in /usr/local/lib/python3.7/dist-packages (0.4.0)\n","Requirement already satisfied: gym~=0.17.0 in /usr/local/lib/python3.7/dist-packages (0.17.3)\n","Requirement already satisfied: Box2D~=2.3.10 in /usr/local/lib/python3.7/dist-packages (2.3.10)\n","Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (4.62.2)\n","Requirement already satisfied: numpy>=1.10.4 in /usr/local/lib/python3.7/dist-packages (from gym~=0.17.0) (1.19.5)\n","Requirement already satisfied: cloudpickle<1.7.0,>=1.2.0 in /usr/local/lib/python3.7/dist-packages (from gym~=0.17.0) (1.3.0)\n","Requirement already satisfied: pyglet<=1.5.0,>=1.4.0 in /usr/local/lib/python3.7/dist-packages (from gym~=0.17.0) (1.5.0)\n","Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from gym~=0.17.0) (1.4.1)\n","Requirement already satisfied: future in /usr/local/lib/python3.7/dist-packages (from pyglet<=1.5.0,>=1.4.0->gym~=0.17.0) (0.16.0)\n","Requirement already satisfied: numba>=0.51.0 in /usr/local/lib/python3.7/dist-packages (from ribs[all]) (0.51.2)\n","Requirement already satisfied: pandas>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from ribs[all]) (1.1.5)\n","Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from ribs[all]) (2.2.0)\n","Requirement already satisfied: scikit-learn>=0.20.0 in /usr/local/lib/python3.7/dist-packages (from ribs[all]) (0.22.2.post1)\n","Requirement already satisfied: decorator>=4.0.0 in /usr/local/lib/python3.7/dist-packages (from ribs[all]) (4.4.2)\n","Requirement already satisfied: sortedcontainers>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from ribs[all]) (2.4.0)\n","Requirement already satisfied: toml>=0.10.0 in /usr/local/lib/python3.7/dist-packages (from ribs[all]) (0.10.2)\n","Requirement already satisfied: matplotlib>=3.0.0 in /usr/local/lib/python3.7/dist-packages (from ribs[all]) (3.2.2)\n","Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib>=3.0.0->ribs[all]) (0.10.0)\n","Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib>=3.0.0->ribs[all]) (2.8.2)\n","Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib>=3.0.0->ribs[all]) (2.4.7)\n","Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib>=3.0.0->ribs[all]) (1.3.2)\n","Requirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from cycler>=0.10->matplotlib>=3.0.0->ribs[all]) (1.15.0)\n","Requirement already satisfied: llvmlite<0.35,>=0.34.0.dev0 in /usr/local/lib/python3.7/dist-packages (from numba>=0.51.0->ribs[all]) (0.34.0)\n","Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from numba>=0.51.0->ribs[all]) (57.4.0)\n","Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.7/dist-packages (from pandas>=1.0.0->ribs[all]) (2018.9)\n","Requirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.7/dist-packages (from scikit-learn>=0.20.0->ribs[all]) (1.0.1)\n"]},{"output_type":"execute_result","data":{"text/plain":["<pyvirtualdisplay.display.Display at 0x7f166cd9de50>"]},"metadata":{},"execution_count":1}]},{"cell_type":"code","metadata":{"id":"sjEM8GiRirCn"},"source":["import gym\n","import random\n","import numpy as np\n","from tensorflow.keras import Sequential\n","from collections import deque\n","from tensorflow.keras.layers import Dense\n","from tensorflow.keras.optimizers import Adam\n","from tensorflow.keras.activations import relu, linear\n","\n","import base64\n","import io\n","from gym.wrappers import Monitor\n","from IPython import display\n","from IPython.display import Image\n","from pyvirtualdisplay import Display\n","import matplotlib.pyplot as plt\n","\n","env = gym.make(\"LunarLander-v2\")\n","env = Monitor(env, 'videos', force=True)\n","np.random.seed(0)\n","\n","d = Display()\n","d.start()\n","\n","\n","# Construct DQN model\n","class DQN:\n","\n","    \"\"\" Implementation of deep q learning algorithm \"\"\"\n","\n","    def __init__(self, action_space, state_space):\n","\n","        self.action_space = action_space\n","        self.state_space = state_space\n","        self.epsilon = 1.0\n","        self.gamma = .99\n","        self.batch_size = 64\n","        self.epsilon_min = .01\n","        self.lr = 0.001\n","        self.epsilon_decay = .996\n","        self.memory = deque(maxlen=1000000)\n","        self.model = self.build_model()\n","\n","    def build_model(self):\n","\n","        model = Sequential()\n","        model.add(Dense(150, input_dim=self.state_space, activation=relu))\n","        model.add(Dense(120, activation=relu))\n","        model.add(Dense(self.action_space, activation=linear))\n","        model.compile(loss='mse', optimizer=Adam(lr=self.lr))\n","        return model\n","\n","    def remember(self, state, action, reward, next_state, done):\n","        self.memory.append((state, action, reward, next_state, done))\n","\n","    def act(self, state):\n","\n","        if np.random.rand() <= self.epsilon:\n","            return random.randrange(self.action_space)\n","        act_values = self.model.predict(state)\n","        return np.argmax(act_values[0])\n","\n","    def replay(self):\n","\n","        if len(self.memory) < self.batch_size:\n","            return\n","\n","        minibatch = random.sample(self.memory, self.batch_size)\n","        states = np.array([i[0] for i in minibatch])\n","        actions = np.array([i[1] for i in minibatch])\n","        rewards = np.array([i[2] for i in minibatch])\n","        next_states = np.array([i[3] for i in minibatch])\n","        dones = np.array([i[4] for i in minibatch])\n","\n","        states = np.squeeze(states)\n","        next_states = np.squeeze(next_states)\n","\n","        targets = rewards + self.gamma*(np.amax(self.model.predict_on_batch(next_states), axis=1))*(1-dones)\n","        targets_full = self.model.predict_on_batch(states)\n","        ind = np.array([i for i in range(self.batch_size)])\n","        targets_full[[ind], [actions]] = targets\n","\n","        self.model.fit(states, targets_full, epochs=1, verbose=0)\n","        if self.epsilon > self.epsilon_min:\n","            self.epsilon *= self.epsilon_decay\n","\n","\n","# Display the lunar lander actions for each episode\n","def render(env):\n","    if len(env.videos) > 0:\n","            f = env.videos[-1]\n","            video = io.open(f[0], 'r+b').read()\n","            encoded = base64.b64encode(video)\n","\n","            display.display(display.HTML(data=\"\"\"\n","                <video alt=\"test\" controls>\n","                <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" />\n","                </video>\n","                \"\"\".format(encoded.decode('ascii'))))\n","\n","# train the DQN model\n","def train_dqn(episode):\n","\n","    loss = []\n","    agent = DQN(env.action_space.n, env.observation_space.shape[0])\n","    for e in range(episode):\n","        state = env.reset()\n","        state = np.reshape(state, (1, 8))\n","        score = 0\n","        max_steps = 3000\n","        for i in range(max_steps):\n","            action = agent.act(state)\n","            next_state, reward, done, _ = env.step(action)\n","            score += reward\n","            next_state = np.reshape(next_state, (1, 8))\n","            agent.remember(state, action, reward, next_state, done)\n","            state = next_state\n","            agent.replay()\n","            if done:\n","                print(\"episode: {}/{}, score: {}\".format(e, episode, score))\n","                break\n","        loss.append(score)\n","        render(env)\n","            \n","        # Average score of last 100 episode\n","        is_solved = np.mean(loss[-100:])\n","        if is_solved > 200:\n","            print('\\n Task Completed! \\n')\n","            break\n","        print(\"Average over last 100 episode: {0:.2f} \\n\".format(is_solved))\n","    return loss\n"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"id":"G148m_UW9sHk","executionInfo":{"status":"ok","timestamp":1631919409433,"user_tz":300,"elapsed":20881,"user":{"displayName":"Ziyu Xiang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"09056639542636885950"}},"outputId":"c62a1de6-3278-4ffa-9da4-11c7e4b43d1c"},"source":["print(env.observation_space)\n","print(env.action_space)\n","episodes = 400\n","loss = train_dqn(episodes)\n","plt.plot([i+1 for i in range(0, len(loss), 2)], loss[::2])\n","plt.show()"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Box(-inf, inf, (8,), float32)\n","Discrete(4)\n"]},{"output_type":"stream","name":"stderr","text":["/usr/local/lib/python3.7/dist-packages/keras/optimizer_v2/optimizer_v2.py:356: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n","  \"The `lr` argument is deprecated, use `learning_rate` instead.\")\n"]},{"output_type":"stream","name":"stdout","text":["episode: 0/3, score: -219.4938750079295\n","Average over last 100 episode: -219.49 \n","\n","episode: 1/3, score: -281.70475740781336\n"]},{"output_type":"display_data","data":{"text/html":["\n","                <video alt=\"test\" controls>\n","                <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n","                </video>\n","                "],"text/plain":["<IPython.core.display.HTML object>"]},"metadata":{}},{"output_type":"stream","name":"stdout","text":["Average over last 100 episode: -250.60 \n","\n","episode: 2/3, score: -438.1160373820796\n"]},{"output_type":"display_data","data":{"text/html":["\n","                <video alt=\"test\" controls>\n","                <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n","                </video>\n","                "],"text/plain":["<IPython.core.display.HTML object>"]},"metadata":{}},{"output_type":"stream","name":"stdout","text":["Average over last 100 episode: -313.10 \n","\n"]},{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 432x288 with 1 Axes>"]},"metadata":{"needs_background":"light"}}]},{"cell_type":"markdown","metadata":{"id":"hIVRDfEQiewh"},"source":["## Reference\n","*Some materials in this section are adapted from several resources listed below:* \n","\n","- https://towardsdatascience.com/\n","- An Introduction to Statistical Learning : with Applications in R by Gareth James, Daniela Witten, Trevor Hastie, Robert Tibshirani. New York: Springer, 2013.\n","- Open Machine Learning Course mlcourse.ai.\n","- Reinforcement Learning: An Introduction (textbook): http://incompleteideas.net/book/the-book-2nd.html"]},{"cell_type":"markdown","metadata":{"id":"NQ2Cud9cEZEj"},"source":["# Questions? "]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":56},"id":"6N8DlOKOxbUk","executionInfo":{"status":"ok","timestamp":1631919409434,"user_tz":300,"elapsed":9,"user":{"displayName":"Ziyu Xiang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"09056639542636885950"}},"outputId":"d4349783-4662-4ae1-d756-befbe2f554f9"},"source":["Image(url= \"https://mirrors.creativecommons.org/presskit/buttons/88x31/png/by-nc-sa.png\", width=100)"],"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/html":["<img src=\"https://mirrors.creativecommons.org/presskit/buttons/88x31/png/by-nc-sa.png\" width=\"100\"/>"],"text/plain":["<IPython.core.display.Image object>"]},"metadata":{},"execution_count":4}]},{"cell_type":"code","metadata":{"id":"bXkjGYbNe9K5"},"source":[""],"execution_count":null,"outputs":[]}]}