{"cells": [{"cell_type": "markdown", "id": "a945dcd7", "metadata": {"papermill": {"duration": 0.003138, "end_time": "2024-07-26T13:10:48.407274", "exception": false, "start_time": "2024-07-26T13:10:48.404136", "status": "completed"}, "tags": []}, "source": ["\n", "# How to train a Deep Q Network\n", "\n", "* **Author:** Lightning.ai\n", "* **License:** CC BY-SA\n", "* **Generated:** 2024-07-26T13:10:41.706715\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,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){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/Lightning-AI/lightning/)\n", "| Check out [the documentation](https://lightning.ai/docs/)\n", "| Join us [on Discord](https://discord.com/invite/tfXFetEZxv)"]}, {"cell_type": "markdown", "id": "994db616", "metadata": {"papermill": {"duration": 0.002471, "end_time": "2024-07-26T13:10:48.412500", "exception": false, "start_time": "2024-07-26T13:10:48.410029", "status": "completed"}, "tags": []}, "source": ["## Setup\n", "This notebook requires some packages besides pytorch-lightning."]}, {"cell_type": "code", "execution_count": 1, "id": "533e70e5", "metadata": {"colab": {}, "colab_type": "code", "execution": {"iopub.execute_input": "2024-07-26T13:10:48.419044Z", "iopub.status.busy": "2024-07-26T13:10:48.418697Z", "iopub.status.idle": "2024-07-26T13:10:49.523590Z", "shell.execute_reply": "2024-07-26T13:10:49.522626Z"}, "id": "LfrJLKPFyhsK", "lines_to_next_cell": 0, "papermill": {"duration": 1.110315, "end_time": "2024-07-26T13:10:49.525494", "exception": false, "start_time": "2024-07-26T13:10:48.415179", "status": "completed"}, "tags": []}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager, possibly rendering your system unusable.It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv. Use the --root-user-action option if you know what you are doing and want to suppress this warning.\u001b[0m\u001b[33m\r\n", "\u001b[0m"]}], "source": ["! pip install --quiet \"pygame\" \"seaborn\" \"numpy <2.0\" \"torchvision ==0.16.*\" \"pytorch-lightning >=2.0,<2.4\" \"matplotlib\" \"pandas\" \"gym <0.24\" \"torch>=1.8.1, <2.5\" \"torchmetrics>=1.0, <1.5\" \"torch ==2.1.*\""]}, {"cell_type": "code", "execution_count": 2, "id": "accbd099", "metadata": {"execution": {"iopub.execute_input": "2024-07-26T13:10:49.532972Z", "iopub.status.busy": "2024-07-26T13:10:49.532584Z", "iopub.status.idle": "2024-07-26T13:10:52.841928Z", "shell.execute_reply": "2024-07-26T13:10:52.840608Z"}, "papermill": {"duration": 3.314935, "end_time": "2024-07-26T13:10:52.843470", "exception": false, "start_time": "2024-07-26T13:10:49.528535", "status": "completed"}, "tags": []}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["/tmp/ipykernel_677/94481177.py:10: DeprecationWarning: Importing display from IPython.core.display is deprecated since IPython 7.14, please import from IPython display\n", "  from IPython.core.display import display\n"]}, {"name": "stderr", "output_type": "stream", "text": ["/usr/local/lib/python3.10/dist-packages/lightning_fabric/__init__.py:41: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html\n", "/usr/local/lib/python3.10/dist-packages/lightning_fabric/__init__.py:41: Deprecated call to `pkg_resources.declare_namespace('lightning_fabric')`.\n", "Implementing implicit namespace packages (as specified in PEP 420) is preferred to `pkg_resources.declare_namespace`. See https://setuptools.pypa.io/en/latest/references/keywords.html#keyword-namespace-packages\n"]}, {"name": "stderr", "output_type": "stream", "text": ["/usr/local/lib/python3.10/dist-packages/pytorch_lightning/__init__.py:37: Deprecated call to `pkg_resources.declare_namespace('pytorch_lightning')`.\n", "Implementing implicit namespace packages (as specified in PEP 420) is preferred to `pkg_resources.declare_namespace`. See https://setuptools.pypa.io/en/latest/references/keywords.html#keyword-namespace-packages\n"]}], "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": "6299c03f", "metadata": {"execution": {"iopub.execute_input": "2024-07-26T13:10:52.850955Z", "iopub.status.busy": "2024-07-26T13:10:52.850560Z", "iopub.status.idle": "2024-07-26T13:10:52.856537Z", "shell.execute_reply": "2024-07-26T13:10:52.855625Z"}, "papermill": {"duration": 0.012032, "end_time": "2024-07-26T13:10:52.858546", "exception": false, "start_time": "2024-07-26T13:10:52.846514", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class DQN(nn.Module):\n", "    def __init__(self, obs_size: int, n_actions: int, hidden_size: int = 128):\n", "        \"\"\"Simple MLP network.\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", "        \"\"\"\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": "80804082", "metadata": {"papermill": {"duration": 0.002872, "end_time": "2024-07-26T13:10:52.864287", "exception": false, "start_time": "2024-07-26T13:10:52.861415", "status": "completed"}, "tags": []}, "source": ["### Memory"]}, {"cell_type": "code", "execution_count": 4, "id": "48e0d481", "metadata": {"execution": {"iopub.execute_input": "2024-07-26T13:10:52.870957Z", "iopub.status.busy": "2024-07-26T13:10:52.870754Z", "iopub.status.idle": "2024-07-26T13:10:52.874885Z", "shell.execute_reply": "2024-07-26T13:10:52.873867Z"}, "papermill": {"duration": 0.009096, "end_time": "2024-07-26T13:10:52.876240", "exception": false, "start_time": "2024-07-26T13:10:52.867144", "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": "bd813c03", "metadata": {"execution": {"iopub.execute_input": "2024-07-26T13:10:52.883271Z", "iopub.status.busy": "2024-07-26T13:10:52.883066Z", "iopub.status.idle": "2024-07-26T13:10:52.889533Z", "shell.execute_reply": "2024-07-26T13:10:52.888570Z"}, "papermill": {"duration": 0.011842, "end_time": "2024-07-26T13:10:52.890965", "exception": false, "start_time": "2024-07-26T13:10:52.879123", "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", "\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", "        \"\"\"\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": "1f3d17e8", "metadata": {"execution": {"iopub.execute_input": "2024-07-26T13:10:52.897946Z", "iopub.status.busy": "2024-07-26T13:10:52.897694Z", "iopub.status.idle": "2024-07-26T13:10:52.903972Z", "shell.execute_reply": "2024-07-26T13:10:52.902990Z"}, "lines_to_next_cell": 2, "papermill": {"duration": 0.011517, "end_time": "2024-07-26T13:10:52.905426", "exception": false, "start_time": "2024-07-26T13:10:52.893909", "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", "\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": "aeb019fd", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.002898, "end_time": "2024-07-26T13:10:52.911244", "exception": false, "start_time": "2024-07-26T13:10:52.908346", "status": "completed"}, "tags": []}, "source": ["### Agent"]}, {"cell_type": "code", "execution_count": 7, "id": "64b4ec45", "metadata": {"execution": {"iopub.execute_input": "2024-07-26T13:10:52.918903Z", "iopub.status.busy": "2024-07-26T13:10:52.918621Z", "iopub.status.idle": "2024-07-26T13:10:52.929221Z", "shell.execute_reply": "2024-07-26T13:10:52.928267Z"}, "lines_to_next_cell": 2, "papermill": {"duration": 0.016538, "end_time": "2024-07-26T13:10:52.930661", "exception": false, "start_time": "2024-07-26T13:10:52.914123", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class Agent:\n", "    def __init__(self, env: gym.Env, replay_buffer: ReplayBuffer) -> None:\n", "        \"\"\"Base Agent class handling the interaction with the environment.\n", "\n", "        Args:\n", "            env: training environment\n", "            replay_buffer: replay buffer storing experiences\n", "\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", "        \"\"\"\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", "        # So, in the deprecated version of gym, the env.step() has 4 values unpacked which is\n", "        #     obs, reward, done, info = env.step(action)\n", "        # In the latest version of gym, the step() function returns back an additional variable which is truncated.\n", "        #     obs, reward, terminated, truncated, info = env.step(action)\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": "cc3bc29a", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.002872, "end_time": "2024-07-26T13:10:52.936437", "exception": false, "start_time": "2024-07-26T13:10:52.933565", "status": "completed"}, "tags": []}, "source": ["### DQN Lightning Module"]}, {"cell_type": "code", "execution_count": 8, "id": "5c836ff1", "metadata": {"execution": {"iopub.execute_input": "2024-07-26T13:10:52.943425Z", "iopub.status.busy": "2024-07-26T13:10:52.943171Z", "iopub.status.idle": "2024-07-26T13:10:52.964467Z", "shell.execute_reply": "2024-07-26T13:10:52.963485Z"}, "papermill": {"duration": 0.026555, "end_time": "2024-07-26T13:10:52.965880", "exception": false, "start_time": "2024-07-26T13:10:52.939325", "status": "completed"}, "tags": []}, "outputs": [], "source": ["class DQNLightning(LightningModule):\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", "        \"\"\"Basic DQN Model.\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", "        \"\"\"\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", "        \"\"\"\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", "        \"\"\"\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", "        \"\"\"\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 based on\n", "        the minibatch received.\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", "        \"\"\"\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": "2a1a549b", "metadata": {"papermill": {"duration": 0.002905, "end_time": "2024-07-26T13:10:52.971897", "exception": false, "start_time": "2024-07-26T13:10:52.968992", "status": "completed"}, "tags": []}, "source": ["### Trainer"]}, {"cell_type": "code", "execution_count": 9, "id": "11a80706", "metadata": {"execution": {"iopub.execute_input": "2024-07-26T13:10:52.979137Z", "iopub.status.busy": "2024-07-26T13:10:52.978812Z", "iopub.status.idle": "2024-07-26T13:11:03.590250Z", "shell.execute_reply": "2024-07-26T13:11:03.589358Z"}, "papermill": {"duration": 10.617966, "end_time": "2024-07-26T13:11:03.592783", "exception": false, "start_time": "2024-07-26T13:10:52.974817", "status": "completed"}, "tags": []}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["/usr/local/lib/python3.10/dist-packages/gym/envs/registration.py:505: UserWarning: \u001b[33mWARN: The environment CartPole-v0 is out of date. You should consider upgrading to version `v1` with the environment ID `CartPole-v1`.\u001b[0m\n", "  logger.warn(\n"]}, {"name": "stderr", "output_type": "stream", "text": ["GPU available: True (cuda), used: True\n"]}, {"name": "stderr", "output_type": "stream", "text": ["TPU available: False, using: 0 TPU cores\n"]}, {"name": "stderr", "output_type": "stream", "text": ["HPU available: False, using: 0 HPUs\n"]}, {"name": "stderr", "output_type": "stream", "text": ["You are using a CUDA device ('NVIDIA GeForce RTX 3090') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n"]}, {"name": "stderr", "output_type": "stream", "text": ["Missing logger folder: logs/lightning_logs\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 | Mode \n", "--------------------------------------------\n", "0 | net        | DQN  | 898    | train\n", "1 | target_net | DQN  | 898    | train\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": ["/usr/local/lib/python3.10/dist-packages/pytorch_lightning/trainer/connectors/data_connector.py:424: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=63` in the `DataLoader` to improve performance.\n", "/usr/local/lib/python3.10/dist-packages/torch/utils/data/_utils/collate.py:175: DeprecationWarning: In future, it will be an error for 'np.bool_' scalars to be interpreted as an index\n", "  return torch.as_tensor(batch)\n"]}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "fc3f5c83caaf4ef59827be5e3a2df9fd", "version_major": 2, "version_minor": 0}, "text/plain": ["Training: |          | 0/? [00:00<?, ?it/s]"]}, "metadata": {}, "output_type": "display_data"}, {"name": "stderr", "output_type": "stream", "text": ["/tmp/ipykernel_677/3381455415.py:34: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at ../torch/csrc/utils/tensor_new.cpp:261.)\n", "  state = torch.tensor([self.state])\n"]}, {"name": "stderr", "output_type": "stream", "text": ["`Trainer.fit` stopped: `max_epochs=150` reached.\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": "9140804c", "metadata": {"execution": {"iopub.execute_input": "2024-07-26T13:11:03.612666Z", "iopub.status.busy": "2024-07-26T13:11:03.612461Z", "iopub.status.idle": "2024-07-26T13:11:03.974460Z", "shell.execute_reply": "2024-07-26T13:11:03.973478Z"}, "papermill": {"duration": 0.373982, "end_time": "2024-07-26T13:11:03.976697", "exception": false, "start_time": "2024-07-26T13:11:03.602715", "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>episode reward</th>\n", "      <th>epsilon</th>\n", "      <th>reward</th>\n", "      <th>total_reward</th>\n", "      <th>train_loss</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>20.0</td>\n", "      <td>0.95149</td>\n", "      <td>1.0</td>\n", "      <td>22.0</td>\n", "      <td>0.099226</td>\n", "    </tr>\n", "    <tr>\n", "      <th>7</th>\n", "      <td>40.0</td>\n", "      <td>0.90199</td>\n", "      <td>1.0</td>\n", "      <td>30.0</td>\n", "      <td>6.272033</td>\n", "    </tr>\n", "    <tr>\n", "      <th>11</th>\n", "      <td>8.0</td>\n", "      <td>0.85249</td>\n", "      <td>1.0</td>\n", "      <td>27.0</td>\n", "      <td>0.955166</td>\n", "    </tr>\n", "    <tr>\n", "      <th>15</th>\n", "      <td>15.0</td>\n", "      <td>0.80299</td>\n", "      <td>1.0</td>\n", "      <td>19.0</td>\n", "      <td>3.187010</td>\n", "    </tr>\n", "    <tr>\n", "      <th>19</th>\n", "      <td>4.0</td>\n", "      <td>0.75349</td>\n", "      <td>1.0</td>\n", "      <td>26.0</td>\n", "      <td>59.000748</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["       episode reward  epsilon  reward  total_reward  train_loss\n", "epoch                                                           \n", "3                20.0  0.95149     1.0          22.0    0.099226\n", "7                40.0  0.90199     1.0          30.0    6.272033\n", "11                8.0  0.85249     1.0          27.0    0.955166\n", "15               15.0  0.80299     1.0          19.0    3.187010\n", "19                4.0  0.75349     1.0          26.0   59.000748"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/plain": ["<seaborn.axisgrid.FacetGrid at 0x7ff7a2984100>"]}, "execution_count": 10, "metadata": {}, "output_type": "execute_result"}, {"data": {"image/png": "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", "text/plain": ["<Figure size 657x500 with 1 Axes>"]}, "metadata": {}, "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": "1fb1cb8a", "metadata": {"papermill": {"duration": 0.011049, "end_time": "2024-07-26T13:11:03.999841", "exception": false, "start_time": "2024-07-26T13:11:03.988792", "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/Lightning-AI/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 [Discord](https://discord.com/invite/tfXFetEZxv)!\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/Lightning-AI/lightning) or [Bolt](https://github.com/Lightning-AI/lightning-bolts)\n", "GitHub Issues page and filter for \"good first issue\".\n", "\n", "* [Lightning good first issue](https://github.com/Lightning-AI/lightning/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)\n", "* [Bolt good first issue](https://github.com/Lightning-AI/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,NDA0OiBOb3QgRm91bmQ=){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.10.12"}, "papermill": {"default_parameters": {}, "duration": 17.772928, "end_time": "2024-07-26T13:11:05.333232", "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": "2024-07-26T13:10:47.560304", "version": "2.6.0"}, "widgets": {"application/vnd.jupyter.widget-state+json": {"state": {"25b238095b1844878ed14b6eac8e783d": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_ecd58032a792473c990b710e8c8cec86", "max": 1.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_dbd41832bac74e209059b33e1d2d734b", "tabbable": null, "tooltip": null, "value": 1.0}}, "49c6b06264844e21bb60e90193b20bbd": {"model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": 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, "padding": null, "right": null, "top": null, "visibility": null, "width": null}}, "4e19a10d8cd848c0a57fd7afb4d4af07": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": {"_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null}}, "7615707eacf448749e87eb913952f41b": {"model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": 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, "padding": null, "right": null, "top": null, "visibility": null, "width": null}}, "79dcbd7ce6804ed495ad6afa9aa727ff": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_49c6b06264844e21bb60e90193b20bbd", "placeholder": "\u200b", "style": "IPY_MODEL_4e19a10d8cd848c0a57fd7afb4d4af07", "tabbable": null, "tooltip": null, "value": "Epoch\u2007149:\u2007"}}, "7eac307db48d4d47b7da354269378683": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_7615707eacf448749e87eb913952f41b", "placeholder": "\u200b", "style": "IPY_MODEL_d0ab890d64704768aa8332c7c0dd3cb7", "tabbable": null, "tooltip": null, "value": "\u200713/?\u2007[00:00&lt;00:00,\u2007194.42it/s,\u2007v_num=0,\u2007total_reward=171.0,\u2007steps=1949.0]"}}, "cec08824efc644ba8d9880bff2f3903e": {"model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": 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, "padding": null, "right": null, "top": null, "visibility": null, "width": "100%"}}, "d0ab890d64704768aa8332c7c0dd3cb7": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": {"_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null}}, "dbd41832bac74e209059b33e1d2d734b": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", "state": {"_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "bar_color": null, "description_width": ""}}, "ecd58032a792473c990b710e8c8cec86": {"model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": {"_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": 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, "padding": null, "right": null, "top": null, "visibility": null, "width": null}}, "fc3f5c83caaf4ef59827be5e3a2df9fd": {"model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", "state": {"_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HBoxView", "box_style": "", "children": ["IPY_MODEL_79dcbd7ce6804ed495ad6afa9aa727ff", "IPY_MODEL_25b238095b1844878ed14b6eac8e783d", "IPY_MODEL_7eac307db48d4d47b7da354269378683"], "layout": "IPY_MODEL_cec08824efc644ba8d9880bff2f3903e", "tabbable": null, "tooltip": null}}}, "version_major": 2, "version_minor": 0}}}, "nbformat": 4, "nbformat_minor": 5}