{"cells": [{"cell_type": "markdown", "id": "ca70018b", "metadata": {"papermill": {"duration": 0.031767, "end_time": "2022-04-28T12:56:14.098871", "exception": false, "start_time": "2022-04-28T12:56:14.067104", "status": "completed"}, "tags": []}, "source": ["\n", "# How to train a Deep Q Network\n", "\n", "* **Author:** PL team\n", "* **License:** CC BY-SA\n", "* **Generated:** 2022-04-28T08:05:34.347059\n", "\n", "Main takeaways:\n", "\n", "1. RL has the same flow as previous models we have seen, with a few additions\n", "2. Handle unsupervised learning by using an IterableDataset where the dataset itself is constantly updated during training\n", "3. Each training step carries has the agent taking an action in the environment and storing the experience in the IterableDataset\n", "\n", "\n", "---\n", "Open in [![Open In Colab](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAHUAAAAUCAYAAACzrHJDAAAIuUlEQVRoQ+1ZaVRURxb+qhdolmbTUVSURpZgmLhHbQVFZIlGQBEXcMvJhKiTEzfigjQg7oNEJ9GMGidnjnNMBs2czIzajksEFRE1xklCTKJiQLRFsUGkoUWw+82pamn79etGYoKek1B/4NW99/tu3e/dquJBAGD27NkHALxKf39WY39gyrOi+i3xqGtUoePJrFmznrmgtModorbTu8YRNZk5cybXTvCtwh7o6NR2KzuZMWNGh6jtVt7nA0ymT5/eJlF9POrh7PAQl6s8bGYa3PUum//htmebVtLRqW0q01M5keTk5FZFzU0oRle3+zxwg5Hgtb+PZiL/ZVohxCI+hL5JgjmfjPxZ26+33BG3dA+ealHPM4gQAo5rU59gsI8bRvl54t3Ca62mvHyUAhtOlLd5WSQpKcluBjumnoCLs1EARkVd9E8l3p9y2i7RbQ1B6pFwu/YDgW8KbHJHMTQrwnjz2oZm9M4pavOCfo5jWrgCaaMVcMs6/pNhDr0+AMN93XlxV7R6DNpyzi7W/OE+yIrsjU6rTrbKV5cd/pNyItOmTbMp6sbBB+EqaYJY4cWE3VUciNt1TpgfcRFv71Fi54xT5kSoyLvOBEJMOMxWXkFlBeBSX4u6Zkcs+3KszYRtiapbNRqF31UgetVuc8z9vBXIv1qD+F1f83B6uDlCUyfsZGepGPpmg01OB7EITQbhS9ribKy+DmP1DUiClLz4bnIHVOqa7BY+Z1wg5g3zgUvyehiNpnJKxSLc/ts76LKm0BzX3c0RNy1yXjDcB5lWoro4iNHQxM+f1kWeWQARAWQS++trISJTp061Kep25X/MycwtjuctSC5rxo7ppi7VNUox5+PhPHtrsS2O1qJ6yx1QujQUzm9sh6hbkBlvvGcN8hYnwjUjH6kjfZEd5c/jitz5Jc5U3ENnFynKl4eB7nyEgP2UZ+Yz3/rVEbyYr27qELrtC4FIC0J7sc7xWnmccdHfRRTs0VB+cA4lt+oFcRR/wUeH8FG5w2Mbx8FQ8TXEvv1xYf4wBP3O2WyL3/UVjpXWgIqaFeUPr+wTmDvUB7njH6/bOv+HRg4SqioAg5GDe1aB3ZeMTJkyRSBqkLsWqSEm0fZVBEN94zEZnYvrdx1JL5cxe+a+AbhSJecRRHW/ikTFRTa38dtQlNZ5CRKwFvUtZU/kvBoEF9Uxni/XqIM+dwKbTw3rhcxIf7gmr2M+H6SMwx8iBzJbw5oxeG3Lv5FX9B3AGaHPS8e8z77H7v9VMpvPG5ug1enh7eGK8h0LBTwUb+GInqzInlRUK65DmTPQu4c3+uQKjwKK77zwUxBX4Tq7yR1RuiwUsqlrABCM6esHdXoy47fk4+prYKy8ZF574x4V5BnHQBuf4g9Z9ld8U36L2aktZNNplNfw7zotwWTy5MkCUft4aLEopJj5/OPHl1BQqeAVOnHgNSQOqmBzq9V9cfEm/yx5ubMGKS9cYPZ3vx2OS/c6PVHUuUO7Y1Pci3BO/1zgq18byebfGemLtNF+6JRtOvMk926ibussZqM+1mNz4TWkH7rCbM5phwGRGDAaoF8fY5OHFnlldAA8sgoEXKnDukA1NgSeNjqkJT9brbN4pC9WRweYXyLugR73c+MYvyWfu0yC6+mjzN1Isfw3FKJS98CU/zI1IHFkFPR52cHL2FJk0sB6kMTERIGo9GzcPkLNfA0cwdwi/hfEYO86ZMd9w+y1egfM2T2Eh/vesMNwljSzuZRT420SW3eqy8N6aHMmwmnFUZ7/PGVPbIoNZvNU1BURdHs0bT2+HjL8sDSM2e6vi4Lj5NW8WOLVA6RTT2azxLV+bglaFNqLieqemS/gWkw7NyoAHo+2dEsiivengjKsPFoqWOvbSh/kxPaxyW/JRzH2Fl3EzD9/xjAefJqB3usKUFn/0Gb+S/d/jy3FN2yLOmnSJJtn6oehByEiHPSeXnDxFGPRnoFoaBJjcdQlbDwcjL1zTNuQpoxD7R0OG0uUTMi0fkVwdzBdYIwcwZunxrVJVLplNm54BZp7jfDfYLoNyqQi1K6KxIdHzmN+QQ2WjFIwUT2zTGdlRXo4NFXVUO4sgX5dFC7f0aP/ZlNeUjFBuL8Xjl6uRuP6aMjSjpjzsH62FDU7JhBuGccEXIvDfJFFBc/gHw80dklfCVYnRaDfpiJcutPA4F7qJsfJeUPQI+1fqMlNhFx1FM0GDqkjFVg7NojlQ0Vt4aM5ReSqcbpaCg8nCW5lRsBvbT4T1TLfFptsfh7gItzuKTdJSEiwKSrt1vcmnEXXrsLbYnWDA1bu+z2WKy9Arq+1KRqdfKsoBo0GcdtEpS/B1bO4v0cFiUhkjskvKcMrWwtAPHuwQq8Z+4LZ1vTQANfXt4J0DwZX9gWa9qh4XDM/voC9JXfwYEMMHJcfNtusn82ihvliVUwg5KrPGVf6GH94ZJpEZBen6EC4qYTHA1dXhW0JIex8txzv//c8lhzXIi/BFxOH9jGbQhZsRalTIBZZ8KkGyZAxeRQvXkFF1TWz/Hm46jNYUnjPbt3JxIkT7f6dSj8qfJJyVvBxgaIlblOyjtysNHWN9fjjqWi7glJfW3/S0Hlj2XnA8PhKT9w6g3Qx3XiXhvuxQsuT1proxBKI/AaZqY1Xz5muvY8G8XkRRCaHsfQsRAFDH/tZPbcYuHotOG0FRIqB4HR3wNVoIPLtz8ycTguu+jpEigE218vd1YCr5m+HpHMvEI9u4LTXwNWaLjl0iPwGAmIpeHx1VeCqTJdPs1/vweweQPO3HC24NhOhnTphwoQnfv6QSY2ICbkNmdSA4h87oaLaiYfn5diIEd4att2erOwJXbPUHp953p6orQVSUVWRAXBT8c/dJ5L9xhzaJGp71GR/wFP8P5V2z10NSC9T93QM2xUg8fHxT+zU9ijeU4naHon8CjFJXFzc8/kn+dN06q9QgF98SYSo2Xen2NjYZy5sR6f+4nLSK5Iam2PH/x87a1YN/t5sBgAAAABJRU5ErkJggg==){height=\"20px\" width=\"117px\"}](https://colab.research.google.com/github/PytorchLightning/lightning-tutorials/blob/publication/.notebooks/lightning_examples/reinforce-learning-DQN.ipynb)\n", "\n", "Give us a \u2b50 [on Github](https://www.github.com/PytorchLightning/pytorch-lightning/)\n", "| Check out [the documentation](https://pytorch-lightning.readthedocs.io/en/stable/)\n", "| Join us [on Slack](https://www.pytorchlightning.ai/community)"]}, {"cell_type": "markdown", "id": "a723e429", "metadata": {"papermill": {"duration": 0.027631, "end_time": "2022-04-28T12:56:14.156552", "exception": false, "start_time": "2022-04-28T12:56:14.128921", "status": "completed"}, "tags": []}, "source": ["## Setup\n", "This notebook requires some packages besides pytorch-lightning."]}, {"cell_type": "code", "execution_count": 1, "id": "523f5401", "metadata": {"colab": {}, "colab_type": "code", "execution": {"iopub.execute_input": "2022-04-28T12:56:14.219388Z", "iopub.status.busy": "2022-04-28T12:56:14.218850Z", "iopub.status.idle": "2022-04-28T12:56:17.557671Z", "shell.execute_reply": "2022-04-28T12:56:17.558094Z"}, "id": "LfrJLKPFyhsK", "lines_to_next_cell": 0, "papermill": {"duration": 3.374029, "end_time": "2022-04-28T12:56:17.558377", "exception": false, "start_time": "2022-04-28T12:56:14.184348", "status": "completed"}, "tags": []}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["\u001b[33mWARNING: You are using pip version 21.3.1; however, version 22.0.4 is available.\r\n", "You should consider upgrading via the '/usr/bin/python3.8 -m pip install --upgrade pip' command.\u001b[0m\r\n"]}], "source": ["! pip install --quiet \"ipython[notebook]\" \"seaborn\" \"torchmetrics>=0.6\" \"pygame\" \"gym\" \"pandas\" \"pytorch-lightning>=1.4\" \"torch>=1.6, <1.9\""]}, {"cell_type": "code", "execution_count": 2, "id": "20ddd89b", "metadata": {"execution": {"iopub.execute_input": "2022-04-28T12:56:17.627508Z", "iopub.status.busy": "2022-04-28T12:56:17.626981Z", "iopub.status.idle": "2022-04-28T12:56:19.713569Z", "shell.execute_reply": "2022-04-28T12:56:19.714005Z"}, "papermill": {"duration": 2.123494, "end_time": "2022-04-28T12:56:19.714180", "exception": false, "start_time": "2022-04-28T12:56:17.590686", "status": "completed"}, "tags": []}, "outputs": [], "source": ["import os\n", "from collections import OrderedDict, deque, namedtuple\n", "from typing import Iterator, List, Tuple\n", "\n", "import gym\n", "import numpy as np\n", "import pandas as pd\n", "import seaborn as sn\n", "import torch\n", "from IPython.core.display import display\n", "from pytorch_lightning import LightningModule, Trainer\n", "from pytorch_lightning.loggers import CSVLogger\n", "from torch import Tensor, nn\n", "from torch.optim import Adam, Optimizer\n", "from torch.utils.data import DataLoader\n", "from torch.utils.data.dataset import IterableDataset\n", "\n", "PATH_DATASETS = os.environ.get(\"PATH_DATASETS\", \".\")"]}, {"cell_type": "code", "execution_count": 3, "id": "cdd4342e", "metadata": {"execution": {"iopub.execute_input": "2022-04-28T12:56:19.777436Z", "iopub.status.busy": "2022-04-28T12:56:19.776915Z", "iopub.status.idle": "2022-04-28T12:56:19.778807Z", "shell.execute_reply": "2022-04-28T12:56:19.779212Z"}, "papermill": {"duration": 0.036088, "end_time": "2022-04-28T12:56:19.779345", "exception": false, "start_time": "2022-04-28T12:56:19.743257", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class DQN(nn.Module):\n", "    \"\"\"Simple MLP network.\"\"\"\n", "\n", "    def __init__(self, obs_size: int, n_actions: int, hidden_size: int = 128):\n", "        \"\"\"\n", "        Args:\n", "            obs_size: observation/state size of the environment\n", "            n_actions: number of discrete actions available in the environment\n", "            hidden_size: size of hidden layers\n", "        \"\"\"\n", "        super().__init__()\n", "        self.net = nn.Sequential(\n", "            nn.Linear(obs_size, hidden_size),\n", "            nn.ReLU(),\n", "            nn.Linear(hidden_size, n_actions),\n", "        )\n", "\n", "    def forward(self, x):\n", "        return self.net(x.float())"]}, {"cell_type": "markdown", "id": "4ad8cc8a", "metadata": {"papermill": {"duration": 0.030859, "end_time": "2022-04-28T12:56:19.839724", "exception": false, "start_time": "2022-04-28T12:56:19.808865", "status": "completed"}, "tags": []}, "source": ["### Memory"]}, {"cell_type": "code", "execution_count": 4, "id": "a25bdee7", "metadata": {"execution": {"iopub.execute_input": "2022-04-28T12:56:19.905479Z", "iopub.status.busy": "2022-04-28T12:56:19.904955Z", "iopub.status.idle": "2022-04-28T12:56:19.906808Z", "shell.execute_reply": "2022-04-28T12:56:19.907215Z"}, "papermill": {"duration": 0.037822, "end_time": "2022-04-28T12:56:19.907361", "exception": false, "start_time": "2022-04-28T12:56:19.869539", "status": "completed"}, "tags": []}, "outputs": [], "source": ["\n", "# Named tuple for storing experience steps gathered in training\n", "Experience = namedtuple(\n", "    \"Experience\",\n", "    field_names=[\"state\", \"action\", \"reward\", \"done\", \"new_state\"],\n", ")"]}, {"cell_type": "code", "execution_count": 5, "id": "f58ca859", "metadata": {"execution": {"iopub.execute_input": "2022-04-28T12:56:19.970796Z", "iopub.status.busy": "2022-04-28T12:56:19.970276Z", "iopub.status.idle": "2022-04-28T12:56:19.972820Z", "shell.execute_reply": "2022-04-28T12:56:19.972388Z"}, "papermill": {"duration": 0.036848, "end_time": "2022-04-28T12:56:19.972936", "exception": false, "start_time": "2022-04-28T12:56:19.936088", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class ReplayBuffer:\n", "    \"\"\"Replay Buffer for storing past experiences allowing the agent to learn from them.\n", "\n", "    Args:\n", "        capacity: size of the buffer\n", "    \"\"\"\n", "\n", "    def __init__(self, capacity: int) -> None:\n", "        self.buffer = deque(maxlen=capacity)\n", "\n", "    def __len__(self) -> None:\n", "        return len(self.buffer)\n", "\n", "    def append(self, experience: Experience) -> None:\n", "        \"\"\"Add experience to the buffer.\n", "\n", "        Args:\n", "            experience: tuple (state, action, reward, done, new_state)\n", "        \"\"\"\n", "        self.buffer.append(experience)\n", "\n", "    def sample(self, batch_size: int) -> Tuple:\n", "        indices = np.random.choice(len(self.buffer), batch_size, replace=False)\n", "        states, actions, rewards, dones, next_states = zip(*(self.buffer[idx] for idx in indices))\n", "\n", "        return (\n", "            np.array(states),\n", "            np.array(actions),\n", "            np.array(rewards, dtype=np.float32),\n", "            np.array(dones, dtype=bool),\n", "            np.array(next_states),\n", "        )"]}, {"cell_type": "code", "execution_count": 6, "id": "5c108e7e", "metadata": {"execution": {"iopub.execute_input": "2022-04-28T12:56:20.036044Z", "iopub.status.busy": "2022-04-28T12:56:20.033381Z", "iopub.status.idle": "2022-04-28T12:56:20.037860Z", "shell.execute_reply": "2022-04-28T12:56:20.038266Z"}, "lines_to_next_cell": 2, "papermill": {"duration": 0.035997, "end_time": "2022-04-28T12:56:20.038397", "exception": false, "start_time": "2022-04-28T12:56:20.002400", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class RLDataset(IterableDataset):\n", "    \"\"\"Iterable Dataset containing the ExperienceBuffer which will be updated with new experiences during training.\n", "\n", "    Args:\n", "        buffer: replay buffer\n", "        sample_size: number of experiences to sample at a time\n", "    \"\"\"\n", "\n", "    def __init__(self, buffer: ReplayBuffer, sample_size: int = 200) -> None:\n", "        self.buffer = buffer\n", "        self.sample_size = sample_size\n", "\n", "    def __iter__(self) -> Iterator[Tuple]:\n", "        states, actions, rewards, dones, new_states = self.buffer.sample(self.sample_size)\n", "        for i in range(len(dones)):\n", "            yield states[i], actions[i], rewards[i], dones[i], new_states[i]"]}, {"cell_type": "markdown", "id": "20779fc6", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.029204, "end_time": "2022-04-28T12:56:20.098456", "exception": false, "start_time": "2022-04-28T12:56:20.069252", "status": "completed"}, "tags": []}, "source": ["### Agent"]}, {"cell_type": "code", "execution_count": 7, "id": "128a705a", "metadata": {"execution": {"iopub.execute_input": "2022-04-28T12:56:20.166166Z", "iopub.status.busy": "2022-04-28T12:56:20.159927Z", "iopub.status.idle": "2022-04-28T12:56:20.168030Z", "shell.execute_reply": "2022-04-28T12:56:20.168464Z"}, "lines_to_next_cell": 2, "papermill": {"duration": 0.040394, "end_time": "2022-04-28T12:56:20.168611", "exception": false, "start_time": "2022-04-28T12:56:20.128217", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class Agent:\n", "    \"\"\"Base Agent class handeling the interaction with the environment.\"\"\"\n", "\n", "    def __init__(self, env: gym.Env, replay_buffer: ReplayBuffer) -> None:\n", "        \"\"\"\n", "        Args:\n", "            env: training environment\n", "            replay_buffer: replay buffer storing experiences\n", "        \"\"\"\n", "        self.env = env\n", "        self.replay_buffer = replay_buffer\n", "        self.reset()\n", "        self.state = self.env.reset()\n", "\n", "    def reset(self) -> None:\n", "        \"\"\"Resents the environment and updates the state.\"\"\"\n", "        self.state = self.env.reset()\n", "\n", "    def get_action(self, net: nn.Module, epsilon: float, device: str) -> int:\n", "        \"\"\"Using the given network, decide what action to carry out using an epsilon-greedy policy.\n", "\n", "        Args:\n", "            net: DQN network\n", "            epsilon: value to determine likelihood of taking a random action\n", "            device: current device\n", "\n", "        Returns:\n", "            action\n", "        \"\"\"\n", "        if np.random.random() < epsilon:\n", "            action = self.env.action_space.sample()\n", "        else:\n", "            state = torch.tensor([self.state])\n", "\n", "            if device not in [\"cpu\"]:\n", "                state = state.cuda(device)\n", "\n", "            q_values = net(state)\n", "            _, action = torch.max(q_values, dim=1)\n", "            action = int(action.item())\n", "\n", "        return action\n", "\n", "    @torch.no_grad()\n", "    def play_step(\n", "        self,\n", "        net: nn.Module,\n", "        epsilon: float = 0.0,\n", "        device: str = \"cpu\",\n", "    ) -> Tuple[float, bool]:\n", "        \"\"\"Carries out a single interaction step between the agent and the environment.\n", "\n", "        Args:\n", "            net: DQN network\n", "            epsilon: value to determine likelihood of taking a random action\n", "            device: current device\n", "\n", "        Returns:\n", "            reward, done\n", "        \"\"\"\n", "\n", "        action = self.get_action(net, epsilon, device)\n", "\n", "        # do step in the environment\n", "        new_state, reward, done, _ = self.env.step(action)\n", "\n", "        exp = Experience(self.state, action, reward, done, new_state)\n", "\n", "        self.replay_buffer.append(exp)\n", "\n", "        self.state = new_state\n", "        if done:\n", "            self.reset()\n", "        return reward, done"]}, {"cell_type": "markdown", "id": "0526a1ef", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.028897, "end_time": "2022-04-28T12:56:20.226764", "exception": false, "start_time": "2022-04-28T12:56:20.197867", "status": "completed"}, "tags": []}, "source": ["### DQN Lightning Module"]}, {"cell_type": "code", "execution_count": 8, "id": "d77076c3", "metadata": {"execution": {"iopub.execute_input": "2022-04-28T12:56:20.301345Z", "iopub.status.busy": "2022-04-28T12:56:20.292991Z", "iopub.status.idle": "2022-04-28T12:56:20.303346Z", "shell.execute_reply": "2022-04-28T12:56:20.303755Z"}, "papermill": {"duration": 0.047912, "end_time": "2022-04-28T12:56:20.303897", "exception": false, "start_time": "2022-04-28T12:56:20.255985", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class DQNLightning(LightningModule):\n", "    \"\"\"Basic DQN Model.\"\"\"\n", "\n", "    def __init__(\n", "        self,\n", "        batch_size: int = 16,\n", "        lr: float = 1e-2,\n", "        env: str = \"CartPole-v0\",\n", "        gamma: float = 0.99,\n", "        sync_rate: int = 10,\n", "        replay_size: int = 1000,\n", "        warm_start_size: int = 1000,\n", "        eps_last_frame: int = 1000,\n", "        eps_start: float = 1.0,\n", "        eps_end: float = 0.01,\n", "        episode_length: int = 200,\n", "        warm_start_steps: int = 1000,\n", "    ) -> None:\n", "        \"\"\"\n", "        Args:\n", "            batch_size: size of the batches\")\n", "            lr: learning rate\n", "            env: gym environment tag\n", "            gamma: discount factor\n", "            sync_rate: how many frames do we update the target network\n", "            replay_size: capacity of the replay buffer\n", "            warm_start_size: how many samples do we use to fill our buffer at the start of training\n", "            eps_last_frame: what frame should epsilon stop decaying\n", "            eps_start: starting value of epsilon\n", "            eps_end: final value of epsilon\n", "            episode_length: max length of an episode\n", "            warm_start_steps: max episode reward in the environment\n", "        \"\"\"\n", "        super().__init__()\n", "        self.save_hyperparameters()\n", "\n", "        self.env = gym.make(self.hparams.env)\n", "        obs_size = self.env.observation_space.shape[0]\n", "        n_actions = self.env.action_space.n\n", "\n", "        self.net = DQN(obs_size, n_actions)\n", "        self.target_net = DQN(obs_size, n_actions)\n", "\n", "        self.buffer = ReplayBuffer(self.hparams.replay_size)\n", "        self.agent = Agent(self.env, self.buffer)\n", "        self.total_reward = 0\n", "        self.episode_reward = 0\n", "        self.populate(self.hparams.warm_start_steps)\n", "\n", "    def populate(self, steps: int = 1000) -> None:\n", "        \"\"\"Carries out several random steps through the environment to initially fill up the replay buffer with\n", "        experiences.\n", "\n", "        Args:\n", "            steps: number of random steps to populate the buffer with\n", "        \"\"\"\n", "        for _ in range(steps):\n", "            self.agent.play_step(self.net, epsilon=1.0)\n", "\n", "    def forward(self, x: Tensor) -> Tensor:\n", "        \"\"\"Passes in a state x through the network and gets the q_values of each action as an output.\n", "\n", "        Args:\n", "            x: environment state\n", "\n", "        Returns:\n", "            q values\n", "        \"\"\"\n", "        output = self.net(x)\n", "        return output\n", "\n", "    def dqn_mse_loss(self, batch: Tuple[Tensor, Tensor]) -> Tensor:\n", "        \"\"\"Calculates the mse loss using a mini batch from the replay buffer.\n", "\n", "        Args:\n", "            batch: current mini batch of replay data\n", "\n", "        Returns:\n", "            loss\n", "        \"\"\"\n", "        states, actions, rewards, dones, next_states = batch\n", "\n", "        state_action_values = self.net(states).gather(1, actions.long().unsqueeze(-1)).squeeze(-1)\n", "\n", "        with torch.no_grad():\n", "            next_state_values = self.target_net(next_states).max(1)[0]\n", "            next_state_values[dones] = 0.0\n", "            next_state_values = next_state_values.detach()\n", "\n", "        expected_state_action_values = next_state_values * self.hparams.gamma + rewards\n", "\n", "        return nn.MSELoss()(state_action_values, expected_state_action_values)\n", "\n", "    def get_epsilon(self, start: int, end: int, frames: int) -> float:\n", "        if self.global_step > frames:\n", "            return end\n", "        return start - (self.global_step / frames) * (start - end)\n", "\n", "    def training_step(self, batch: Tuple[Tensor, Tensor], nb_batch) -> OrderedDict:\n", "        \"\"\"Carries out a single step through the environment to update the replay buffer. Then calculates loss\n", "        based on the minibatch recieved.\n", "\n", "        Args:\n", "            batch: current mini batch of replay data\n", "            nb_batch: batch number\n", "\n", "        Returns:\n", "            Training loss and log metrics\n", "        \"\"\"\n", "        device = self.get_device(batch)\n", "        epsilon = self.get_epsilon(self.hparams.eps_start, self.hparams.eps_end, self.hparams.eps_last_frame)\n", "        self.log(\"epsilon\", epsilon)\n", "\n", "        # step through environment with agent\n", "        reward, done = self.agent.play_step(self.net, epsilon, device)\n", "        self.episode_reward += reward\n", "        self.log(\"episode reward\", self.episode_reward)\n", "\n", "        # calculates training loss\n", "        loss = self.dqn_mse_loss(batch)\n", "\n", "        if done:\n", "            self.total_reward = self.episode_reward\n", "            self.episode_reward = 0\n", "\n", "        # Soft update of target network\n", "        if self.global_step % self.hparams.sync_rate == 0:\n", "            self.target_net.load_state_dict(self.net.state_dict())\n", "\n", "        self.log_dict(\n", "            {\n", "                \"reward\": reward,\n", "                \"train_loss\": loss,\n", "            }\n", "        )\n", "        self.log(\"total_reward\", self.total_reward, prog_bar=True)\n", "        self.log(\"steps\", self.global_step, logger=False, prog_bar=True)\n", "\n", "        return loss\n", "\n", "    def configure_optimizers(self) -> List[Optimizer]:\n", "        \"\"\"Initialize Adam optimizer.\"\"\"\n", "        optimizer = Adam(self.net.parameters(), lr=self.hparams.lr)\n", "        return optimizer\n", "\n", "    def __dataloader(self) -> DataLoader:\n", "        \"\"\"Initialize the Replay Buffer dataset used for retrieving experiences.\"\"\"\n", "        dataset = RLDataset(self.buffer, self.hparams.episode_length)\n", "        dataloader = DataLoader(\n", "            dataset=dataset,\n", "            batch_size=self.hparams.batch_size,\n", "        )\n", "        return dataloader\n", "\n", "    def train_dataloader(self) -> DataLoader:\n", "        \"\"\"Get train loader.\"\"\"\n", "        return self.__dataloader()\n", "\n", "    def get_device(self, batch) -> str:\n", "        \"\"\"Retrieve device currently being used by minibatch.\"\"\"\n", "        return batch[0].device.index if self.on_gpu else \"cpu\""]}, {"cell_type": "markdown", "id": "5d33f5a0", "metadata": {"papermill": {"duration": 0.029164, "end_time": "2022-04-28T12:56:20.362319", "exception": false, "start_time": "2022-04-28T12:56:20.333155", "status": "completed"}, "tags": []}, "source": ["### Trainer"]}, {"cell_type": "code", "execution_count": 9, "id": "e026a5a3", "metadata": {"execution": {"iopub.execute_input": "2022-04-28T12:56:20.427732Z", "iopub.status.busy": "2022-04-28T12:56:20.425538Z", "iopub.status.idle": "2022-04-28T12:56:38.761133Z", "shell.execute_reply": "2022-04-28T12:56:38.760681Z"}, "papermill": {"duration": 18.36895, "end_time": "2022-04-28T12:56:38.761267", "exception": false, "start_time": "2022-04-28T12:56:20.392317", "status": "completed"}, "tags": []}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["GPU available: True, used: True\n"]}, {"name": "stderr", "output_type": "stream", "text": ["TPU available: False, using: 0 TPU cores\n"]}, {"name": "stderr", "output_type": "stream", "text": ["IPU available: False, using: 0 IPUs\n"]}, {"name": "stderr", "output_type": "stream", "text": ["HPU available: False, using: 0 HPUs\n"]}, {"name": "stderr", "output_type": "stream", "text": ["LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n"]}, {"name": "stderr", "output_type": "stream", "text": ["\n", "  | Name       | Type | Params\n", "------------------------------------\n", "0 | net        | DQN  | 898   \n", "1 | target_net | DQN  | 898   \n", "------------------------------------\n", "1.8 K     Trainable params\n", "0         Non-trainable params\n", "1.8 K     Total params\n", "0.007     Total estimated model params size (MB)\n"]}, {"name": "stderr", "output_type": "stream", "text": ["/home/AzDevOps_azpcontainer/.local/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:240: PossibleUserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 12 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", "  rank_zero_warn(\n"]}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "dbe8a00c1de94b83b3013847ea2f5940", "version_major": 2, "version_minor": 0}, "text/plain": ["Training: 0it [00:00, ?it/s]"]}, "metadata": {}, "output_type": "display_data"}, {"name": "stderr", "output_type": "stream", "text": ["/home/AzDevOps_azpcontainer/.local/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/logger_connector/result.py:229: UserWarning: You called `self.log('total_reward', ...)` in your `training_step` but the value needs to be floating point. Converting it to torch.float32.\n", "  warning_cache.warn(\n", "/home/AzDevOps_azpcontainer/.local/lib/python3.8/site-packages/pytorch_lightning/trainer/connectors/logger_connector/result.py:229: UserWarning: You called `self.log('steps', ...)` in your `training_step` but the value needs to be floating point. Converting it to torch.float32.\n", "  warning_cache.warn(\n"]}], "source": ["\n", "model = DQNLightning()\n", "\n", "trainer = Trainer(\n", "    accelerator=\"auto\",\n", "    devices=1 if torch.cuda.is_available() else None,  # limiting got iPython runs\n", "    max_epochs=150,\n", "    val_check_interval=50,\n", "    logger=CSVLogger(save_dir=\"logs/\"),\n", ")\n", "\n", "trainer.fit(model)"]}, {"cell_type": "code", "execution_count": 10, "id": "ec06ad77", "metadata": {"execution": {"iopub.execute_input": "2022-04-28T12:56:38.838651Z", "iopub.status.busy": "2022-04-28T12:56:38.838157Z", "iopub.status.idle": "2022-04-28T12:56:39.245747Z", "shell.execute_reply": "2022-04-28T12:56:39.246149Z"}, "papermill": {"duration": 0.448227, "end_time": "2022-04-28T12:56:39.246313", "exception": false, "start_time": "2022-04-28T12:56:38.798086", "status": "completed"}, "tags": []}, "outputs": [{"data": {"text/html": ["<div>\n", "<style scoped>\n", "    .dataframe tbody tr th:only-of-type {\n", "        vertical-align: middle;\n", "    }\n", "\n", "    .dataframe tbody tr th {\n", "        vertical-align: top;\n", "    }\n", "\n", "    .dataframe thead th {\n", "        text-align: right;\n", "    }\n", "</style>\n", "<table border=\"1\" class=\"dataframe\">\n", "  <thead>\n", "    <tr style=\"text-align: right;\">\n", "      <th></th>\n", "      <th>epsilon</th>\n", "      <th>episode reward</th>\n", "      <th>reward</th>\n", "      <th>train_loss</th>\n", "      <th>total_reward</th>\n", "    </tr>\n", "    <tr>\n", "      <th>epoch</th>\n", "      <th></th>\n", "      <th></th>\n", "      <th></th>\n", "      <th></th>\n", "      <th></th>\n", "    </tr>\n", "  </thead>\n", "  <tbody>\n", "    <tr>\n", "      <th>3</th>\n", "      <td>0.95149</td>\n", "      <td>5.0</td>\n", "      <td>1.0</td>\n", "      <td>0.189056</td>\n", "      <td>22.0</td>\n", "    </tr>\n", "    <tr>\n", "      <th>7</th>\n", "      <td>0.90199</td>\n", "      <td>15.0</td>\n", "      <td>1.0</td>\n", "      <td>1.432721</td>\n", "      <td>12.0</td>\n", "    </tr>\n", "    <tr>\n", "      <th>11</th>\n", "      <td>0.85249</td>\n", "      <td>18.0</td>\n", "      <td>1.0</td>\n", "      <td>30.838800</td>\n", "      <td>14.0</td>\n", "    </tr>\n", "    <tr>\n", "      <th>15</th>\n", "      <td>0.80299</td>\n", "      <td>68.0</td>\n", "      <td>1.0</td>\n", "      <td>3.394485</td>\n", "      <td>14.0</td>\n", "    </tr>\n", "    <tr>\n", "      <th>19</th>\n", "      <td>0.75349</td>\n", "      <td>21.0</td>\n", "      <td>1.0</td>\n", "      <td>18.886366</td>\n", "      <td>15.0</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["       epsilon  episode reward  reward  train_loss  total_reward\n", "epoch                                                           \n", "3      0.95149             5.0     1.0    0.189056          22.0\n", "7      0.90199            15.0     1.0    1.432721          12.0\n", "11     0.85249            18.0     1.0   30.838800          14.0\n", "15     0.80299            68.0     1.0    3.394485          14.0\n", "19     0.75349            21.0     1.0   18.886366          15.0"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/plain": ["<seaborn.axisgrid.FacetGrid at 0x7f02190640d0>"]}, "execution_count": 10, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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\n", "text/plain": ["<Figure size 472.75x360 with 1 Axes>"]}, "metadata": {"needs_background": "light"}, "output_type": "display_data"}], "source": ["\n", "metrics = pd.read_csv(f\"{trainer.logger.log_dir}/metrics.csv\")\n", "del metrics[\"step\"]\n", "metrics.set_index(\"epoch\", inplace=True)\n", "display(metrics.dropna(axis=1, how=\"all\").head())\n", "sn.relplot(data=metrics, kind=\"line\")"]}, {"cell_type": "markdown", "id": "a5152630", "metadata": {"papermill": {"duration": 0.040482, "end_time": "2022-04-28T12:56:39.328199", "exception": false, "start_time": "2022-04-28T12:56:39.287717", "status": "completed"}, "tags": []}, "source": ["## Congratulations - Time to Join the Community!\n", "\n", "Congratulations on completing this notebook tutorial! If you enjoyed this and would like to join the Lightning\n", "movement, you can do so in the following ways!\n", "\n", "### Star [Lightning](https://github.com/PyTorchLightning/pytorch-lightning) on GitHub\n", "The easiest way to help our community is just by starring the GitHub repos! This helps raise awareness of the cool\n", "tools we're building.\n", "\n", "### Join our [Slack](https://www.pytorchlightning.ai/community)!\n", "The best way to keep up to date on the latest advancements is to join our community! Make sure to introduce yourself\n", "and share your interests in `#general` channel\n", "\n", "\n", "### Contributions !\n", "The best way to contribute to our community is to become a code contributor! At any time you can go to\n", "[Lightning](https://github.com/PyTorchLightning/pytorch-lightning) or [Bolt](https://github.com/PyTorchLightning/lightning-bolts)\n", "GitHub Issues page and filter for \"good first issue\".\n", "\n", "* [Lightning good first issue](https://github.com/PyTorchLightning/pytorch-lightning/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)\n", "* [Bolt good first issue](https://github.com/PyTorchLightning/lightning-bolts/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)\n", "* You can also contribute your own notebooks with useful examples !\n", "\n", "### Great thanks from the entire Pytorch Lightning Team for your interest !\n", "\n", "[![Pytorch Lightning](data:image/png;base64,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){height=\"60px\" width=\"240px\"}](https://pytorchlightning.ai)"]}, {"cell_type": "raw", "metadata": {"raw_mimetype": "text/restructuredtext"}, "source": [".. customcarditem::\n", "   :header: How to train a Deep Q Network\n", "   :card_description: Main takeaways:  1. RL has the same flow as previous models we have seen, with a few additions 2. Handle unsupervised learning by using an IterableDataset where the dataset...\n", "   :tags: RL,GPU/TPU,Lightning-Examples"]}], "metadata": {"jupytext": {"cell_metadata_filter": "colab_type,id,colab,-all", "formats": "ipynb,py:percent", "main_language": "python"}, "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.8.12"}, "papermill": {"default_parameters": {}, "duration": 27.646782, "end_time": "2022-04-28T12:56:40.177952", "environment_variables": {}, "exception": null, "input_path": "lightning_examples/reinforce-learning-DQN/dqn.ipynb", "output_path": ".notebooks/lightning_examples/reinforce-learning-DQN.ipynb", "parameters": {}, "start_time": "2022-04-28T12:56:12.531170", "version": "2.3.4"}, "widgets": {"application/vnd.jupyter.widget-state+json": {"state": {"05064253be494384a9d635234217b5dd": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": {"_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": ""}}, "1c02c26a2a414891b8fee0a16336d57f": {"model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": "2", "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null}}, "1f07ee7908544bdb8bec422b9d950040": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_4621f6ebf4cf40289ae7e035b9adb3fd", "placeholder": "\u200b", "style": "IPY_MODEL_2d3298321de24088b41bb438812b2795", "value": "Epoch 149: "}}, "22c787b404204893a82471f1a84a5d74": {"model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": "inline-flex", "flex": null, "flex_flow": "row wrap", "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": "100%"}}, "2d3298321de24088b41bb438812b2795": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": {"_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": ""}}, "4621f6ebf4cf40289ae7e035b9adb3fd": {"model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null}}, "566919922f744e4886abceb34314e954": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "ProgressStyleModel", "state": {"_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "bar_color": null, "description_width": ""}}, "813f369b769448a689615dd47cc401fd": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "FloatProgressModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_1c02c26a2a414891b8fee0a16336d57f", "max": 1.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_566919922f744e4886abceb34314e954", "value": 1.0}}, "9d315e5cd5694a43b579f0ef98d98f84": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_b9552087e7f945cabf53728d7bec0c6b", "placeholder": "\u200b", "style": "IPY_MODEL_05064253be494384a9d635234217b5dd", "value": " 13/? [00:15&lt;00:00,  1.16s/it, loss=10.2, v_num=4, total_reward=144.0, steps=1949.0]"}}, "b9552087e7f945cabf53728d7bec0c6b": {"model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null}}, "dbe8a00c1de94b83b3013847ea2f5940": {"model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HBoxModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HBoxView", "box_style": "", "children": ["IPY_MODEL_1f07ee7908544bdb8bec422b9d950040", "IPY_MODEL_813f369b769448a689615dd47cc401fd", "IPY_MODEL_9d315e5cd5694a43b579f0ef98d98f84"], "layout": "IPY_MODEL_22c787b404204893a82471f1a84a5d74"}}}, "version_major": 2, "version_minor": 0}}}, "nbformat": 4, "nbformat_minor": 5}