{"cells": [{"cell_type": "markdown", "id": "60584fab", "metadata": {"papermill": {"duration": 0.005693, "end_time": "2025-05-01T12:04:05.397159", "exception": false, "start_time": "2025-05-01T12:04:05.391466", "status": "completed"}, "tags": []}, "source": ["\n", "# How to train a Deep Q Network\n", "\n", "* **Author:** Lightning.ai\n", "* **License:** CC BY-SA\n", "* **Generated:** 2025-05-01T12:03:58.884232\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": "5894647c", "metadata": {"papermill": {"duration": 0.00475, "end_time": "2025-05-01T12:04:05.407459", "exception": false, "start_time": "2025-05-01T12:04:05.402709", "status": "completed"}, "tags": []}, "source": ["## Setup\n", "This notebook requires some packages besides pytorch-lightning."]}, {"cell_type": "code", "execution_count": 1, "id": "dfc12fc7", "metadata": {"colab": {}, "colab_type": "code", "execution": {"iopub.execute_input": "2025-05-01T12:04:05.418315Z", "iopub.status.busy": "2025-05-01T12:04:05.418070Z", "iopub.status.idle": "2025-05-01T12:04:06.588058Z", "shell.execute_reply": "2025-05-01T12:04:06.586747Z"}, "id": "LfrJLKPFyhsK", "lines_to_next_cell": 0, "papermill": {"duration": 1.177502, "end_time": "2025-05-01T12:04:06.589972", "exception": false, "start_time": "2025-05-01T12:04:05.412470", "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 \"torchvision ==0.16.*\" \"pytorch-lightning >=2.0,<2.6\" \"pandas\" \"gym <0.24\" \"pygame\" \"matplotlib\" \"seaborn\" \"torch ==2.1.*\" \"torchmetrics>=1.0, <1.8\" \"numpy <2.0\" \"numpy <3.0\" \"torch>=1.8.1, <2.8\""]}, {"cell_type": "code", "execution_count": 2, "id": "a8897bf7", "metadata": {"execution": {"iopub.execute_input": "2025-05-01T12:04:06.602205Z", "iopub.status.busy": "2025-05-01T12:04:06.601662Z", "iopub.status.idle": "2025-05-01T12:04:09.871934Z", "shell.execute_reply": "2025-05-01T12:04:09.870667Z"}, "papermill": {"duration": 3.27835, "end_time": "2025-05-01T12:04:09.873834", "exception": false, "start_time": "2025-05-01T12:04:06.595484", "status": "completed"}, "tags": []}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["/tmp/ipykernel_698/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"]}], "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": "f5a81e69", "metadata": {"execution": {"iopub.execute_input": "2025-05-01T12:04:09.886511Z", "iopub.status.busy": "2025-05-01T12:04:09.886123Z", "iopub.status.idle": "2025-05-01T12:04:09.891843Z", "shell.execute_reply": "2025-05-01T12:04:09.890903Z"}, "papermill": {"duration": 0.013531, "end_time": "2025-05-01T12:04:09.893351", "exception": false, "start_time": "2025-05-01T12:04:09.879820", "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": "f95feea7", "metadata": {"papermill": {"duration": 0.005166, "end_time": "2025-05-01T12:04:09.903705", "exception": false, "start_time": "2025-05-01T12:04:09.898539", "status": "completed"}, "tags": []}, "source": ["### Memory"]}, {"cell_type": "code", "execution_count": 4, "id": "cbeae23f", "metadata": {"execution": {"iopub.execute_input": "2025-05-01T12:04:09.914797Z", "iopub.status.busy": "2025-05-01T12:04:09.914618Z", "iopub.status.idle": "2025-05-01T12:04:09.918581Z", "shell.execute_reply": "2025-05-01T12:04:09.917733Z"}, "papermill": {"duration": 0.011151, "end_time": "2025-05-01T12:04:09.919951", "exception": false, "start_time": "2025-05-01T12:04:09.908800", "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": "826c64ab", "metadata": {"execution": {"iopub.execute_input": "2025-05-01T12:04:09.931289Z", "iopub.status.busy": "2025-05-01T12:04:09.931112Z", "iopub.status.idle": "2025-05-01T12:04:09.936998Z", "shell.execute_reply": "2025-05-01T12:04:09.936063Z"}, "papermill": {"duration": 0.013207, "end_time": "2025-05-01T12:04:09.938382", "exception": false, "start_time": "2025-05-01T12:04:09.925175", "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": "28b7991b", "metadata": {"execution": {"iopub.execute_input": "2025-05-01T12:04:09.949918Z", "iopub.status.busy": "2025-05-01T12:04:09.949746Z", "iopub.status.idle": "2025-05-01T12:04:09.954885Z", "shell.execute_reply": "2025-05-01T12:04:09.953935Z"}, "lines_to_next_cell": 2, "papermill": {"duration": 0.012612, "end_time": "2025-05-01T12:04:09.956405", "exception": false, "start_time": "2025-05-01T12:04:09.943793", "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": "d0a50d33", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.005256, "end_time": "2025-05-01T12:04:09.966961", "exception": false, "start_time": "2025-05-01T12:04:09.961705", "status": "completed"}, "tags": []}, "source": ["### Agent"]}, {"cell_type": "code", "execution_count": 7, "id": "ebe5d53a", "metadata": {"execution": {"iopub.execute_input": "2025-05-01T12:04:09.978078Z", "iopub.status.busy": "2025-05-01T12:04:09.977503Z", "iopub.status.idle": "2025-05-01T12:04:09.985397Z", "shell.execute_reply": "2025-05-01T12:04:09.984471Z"}, "lines_to_next_cell": 2, "papermill": {"duration": 0.014356, "end_time": "2025-05-01T12:04:09.986586", "exception": false, "start_time": "2025-05-01T12:04:09.972230", "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": "64660aaf", "metadata": {"lines_to_next_cell": 2, "papermill": {"duration": 0.003389, "end_time": "2025-05-01T12:04:09.993419", "exception": false, "start_time": "2025-05-01T12:04:09.990030", "status": "completed"}, "tags": []}, "source": ["### DQN Lightning Module"]}, {"cell_type": "code", "execution_count": 8, "id": "287f30f8", "metadata": {"execution": {"iopub.execute_input": "2025-05-01T12:04:10.001176Z", "iopub.status.busy": "2025-05-01T12:04:10.001008Z", "iopub.status.idle": "2025-05-01T12:04:10.014873Z", "shell.execute_reply": "2025-05-01T12:04:10.013930Z"}, "papermill": {"duration": 0.019216, "end_time": "2025-05-01T12:04:10.015996", "exception": false, "start_time": "2025-05-01T12:04:09.996780", "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": "7545eb36", "metadata": {"papermill": {"duration": 0.003343, "end_time": "2025-05-01T12:04:10.022827", "exception": false, "start_time": "2025-05-01T12:04:10.019484", "status": "completed"}, "tags": []}, "source": ["### Trainer"]}, {"cell_type": "code", "execution_count": 9, "id": "ed1b3d14", "metadata": {"execution": {"iopub.execute_input": "2025-05-01T12:04:10.030377Z", "iopub.status.busy": "2025-05-01T12:04:10.030203Z", "iopub.status.idle": "2025-05-01T12:04:23.675861Z", "shell.execute_reply": "2025-05-01T12:04:23.675008Z"}, "papermill": {"duration": 13.651539, "end_time": "2025-05-01T12:04:23.677729", "exception": false, "start_time": "2025-05-01T12:04:10.026190", "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", "/usr/local/lib/python3.10/dist-packages/pygame/pkgdata.py:25: DeprecationWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html\n", "  from pkg_resources import resource_stream, resource_exists\n", "Using default `ModelCheckpoint`. Consider installing `litmodels` package to enable `LitModelCheckpoint` for automatic upload to the Lightning model registry.\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": ["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", "10        Modules in train mode\n", "0         Modules in eval mode\n"]}, {"name": "stderr", "output_type": "stream", "text": ["/usr/local/lib/python3.10/dist-packages/pytorch_lightning/trainer/connectors/data_connector.py:425: 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": "a2f5974dcf644f4c9ad6e831f64fadd7", "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_698/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": "3bbe9d15", "metadata": {"execution": {"iopub.execute_input": "2025-05-01T12:04:23.694937Z", "iopub.status.busy": "2025-05-01T12:04:23.694748Z", "iopub.status.idle": "2025-05-01T12:04:24.018727Z", "shell.execute_reply": "2025-05-01T12:04:24.018002Z"}, "papermill": {"duration": 0.333484, "end_time": "2025-05-01T12:04:24.020266", "exception": false, "start_time": "2025-05-01T12:04:23.686782", "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>11.0</td>\n", "      <td>0.95149</td>\n", "      <td>1.0</td>\n", "      <td>18.0</td>\n", "      <td>6.581696</td>\n", "    </tr>\n", "    <tr>\n", "      <th>7</th>\n", "      <td>1.0</td>\n", "      <td>0.90199</td>\n", "      <td>1.0</td>\n", "      <td>14.0</td>\n", "      <td>4.729345</td>\n", "    </tr>\n", "    <tr>\n", "      <th>11</th>\n", "      <td>4.0</td>\n", "      <td>0.85249</td>\n", "      <td>1.0</td>\n", "      <td>13.0</td>\n", "      <td>21.101511</td>\n", "    </tr>\n", "    <tr>\n", "      <th>15</th>\n", "      <td>13.0</td>\n", "      <td>0.80299</td>\n", "      <td>1.0</td>\n", "      <td>15.0</td>\n", "      <td>2.789229</td>\n", "    </tr>\n", "    <tr>\n", "      <th>19</th>\n", "      <td>2.0</td>\n", "      <td>0.75349</td>\n", "      <td>1.0</td>\n", "      <td>21.0</td>\n", "      <td>8.440090</td>\n", "    </tr>\n", "  </tbody>\n", "</table>\n", "</div>"], "text/plain": ["       episode reward  epsilon  reward  total_reward  train_loss\n", "epoch                                                           \n", "3                11.0  0.95149     1.0          18.0    6.581696\n", "7                 1.0  0.90199     1.0          14.0    4.729345\n", "11                4.0  0.85249     1.0          13.0   21.101511\n", "15               13.0  0.80299     1.0          15.0    2.789229\n", "19                2.0  0.75349     1.0          21.0    8.440090"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/plain": ["<seaborn.axisgrid.FacetGrid at 0x7f089bb06350>"]}, "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": "84ef115a", "metadata": {"papermill": {"duration": 0.009792, "end_time": "2025-05-01T12:04:24.041340", "exception": false, "start_time": "2025-05-01T12:04:24.031548", "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": "id,colab,colab_type,-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": 22.204977, "end_time": "2025-05-01T12:04:26.613132", "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": "2025-05-01T12:04:04.408155", "version": "2.6.0"}, "widgets": {"application/vnd.jupyter.widget-state+json": {"state": {"1740ee7de73947bebce627774b389a06": {"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_e95814c032024bd085df7c54ceaa76a5", "max": 1.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_8e3a6217c7b94367aeecf5e58fd466f4", "tabbable": null, "tooltip": null, "value": 1.0}}, "4133b4e9c5674db596beafd6ddb81413": {"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_6de87163805146f3a3dcb0543da1de3a", "placeholder": "\u200b", "style": "IPY_MODEL_ae3214806b5741ffabe938f9e8d6e54d", "tabbable": null, "tooltip": null, "value": "Epoch\u2007149:\u2007"}}, "64b783420a214885841d9659b251850c": {"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_e75e273aeb20479f93aa251c693eb779", "placeholder": "\u200b", "style": "IPY_MODEL_a12e7467425648d888221e500a3f0816", "tabbable": null, "tooltip": null, "value": "\u200713/?\u2007[00:00&lt;00:00,\u2007154.38it/s,\u2007v_num=0,\u2007total_reward=200.0,\u2007steps=1949.0]"}}, "6de87163805146f3a3dcb0543da1de3a": {"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}}, "8e3a6217c7b94367aeecf5e58fd466f4": {"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": ""}}, "a12e7467425648d888221e500a3f0816": {"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}}, "a2f5974dcf644f4c9ad6e831f64fadd7": {"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_4133b4e9c5674db596beafd6ddb81413", "IPY_MODEL_1740ee7de73947bebce627774b389a06", "IPY_MODEL_64b783420a214885841d9659b251850c"], "layout": "IPY_MODEL_d67521bd2b32468c8c76dd48a52b4256", "tabbable": null, "tooltip": null}}, "ae3214806b5741ffabe938f9e8d6e54d": {"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}}, "d67521bd2b32468c8c76dd48a52b4256": {"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%"}}, "e75e273aeb20479f93aa251c693eb779": {"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}}, "e95814c032024bd085df7c54ceaa76a5": {"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}}}, "version_major": 2, "version_minor": 0}}}, "nbformat": 4, "nbformat_minor": 5}