MarioBros_Q_Learning.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d2642cae-bc59-4a30-a604-ea6678ed87a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Steve\\anaconda3\\envs\\gymenv\\lib\\site-packages\\gym\\envs\\registration.py:555: UserWarning: \u001b[33mWARN: The environment SuperMarioBros-1-1-v0 is out of date. You should consider upgrading to version `v3`.\u001b[0m\n",
      "  logger.warn(\n",
      "C:\\Users\\Steve\\anaconda3\\envs\\gymenv\\lib\\site-packages\\gym\\envs\\registration.py:627: UserWarning: \u001b[33mWARN: The environment creator metadata doesn't include `render_modes`, contains: ['render.modes', 'video.frames_per_second']\u001b[0m\n",
      "  logger.warn(\n",
      "C:\\Users\\Steve\\anaconda3\\envs\\gymenv\\lib\\site-packages\\gym\\utils\\passive_env_checker.py:233: DeprecationWarning: `np.bool8` is a deprecated alias for `np.bool_`.  (Deprecated NumPy 1.24)\n",
      "  if not isinstance(terminated, (bool, np.bool8)):\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(240, 256, 3),\n",
      " 0.0,\n",
      " False,\n",
      " {'coins': 0, 'flag_get': False, 'life': 2, 'score': 0, 'stage': 1, 'status': 'small', 'time': 400, 'world': 1, 'x_pos': 40, 'y_pos': 79}\n",
      "Using CUDA: True\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "from torchvision import transforms as T\n",
    "from PIL import Image\n",
    "import numpy as np\n",
    "from pathlib import Path\n",
    "from collections import deque\n",
    "import random, datetime, os\n",
    "import numpy as np\n",
    "import time, datetime\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Gym is an OpenAI toolkit for RL\n",
    "import gym\n",
    "from gym.spaces import Box\n",
    "from gym.wrappers import FrameStack\n",
    "\n",
    "# NES Emulator for OpenAI Gym\n",
    "from nes_py.wrappers import JoypadSpace\n",
    "\n",
    "# Super Mario environment for OpenAI Gym\n",
    "import gym_super_mario_bros\n",
    "\n",
    "from tensordict import TensorDict\n",
    "from torchrl.data import TensorDictReplayBuffer, LazyMemmapStorage\n",
    "\n",
    "# Initialize Super Mario environment (in v0.26 change render mode to 'human' to see results on the screen)\n",
    "if gym.__version__ < '0.26':\n",
    "    env = gym_super_mario_bros.make(\"SuperMarioBros-1-1-v0\", new_step_api=True)\n",
    "else:\n",
    "    env = gym_super_mario_bros.make(\"SuperMarioBros-1-1-v0\", render_mode='rgb', apply_api_compatibility=True)\n",
    "\n",
    "# Limit the action-space to\n",
    "#   0. walk right\n",
    "#   1. jump right\n",
    "\n",
    "env = JoypadSpace(env, [[\"right\"], [\"right\", \"A\"]])\n",
    "# env = JoypadSpace(env, [\n",
    "#     ['NOOP'],\n",
    "#     ['right'],\n",
    "#     ['right', 'A'],\n",
    "#     ['right', 'B'],\n",
    "#     ['right', 'A', 'B'],\n",
    "#     ['A'],\n",
    "#     ['left']\n",
    "# ])\n",
    "\n",
    "env.reset()\n",
    "next_state, reward, done, trunc, info = env.step(action=0)\n",
    "print(f\"{next_state.shape},\\n {reward},\\n {done},\\n {info}\")\n",
    "\n",
    "class SkipFrame(gym.Wrapper):\n",
    "    def __init__(self, env, skip):\n",
    "        super().__init__(env)\n",
    "        self._skip = skip\n",
    "\n",
    "    def step(self, action):\n",
    "        total_reward = 0.0\n",
    "        for i in range(self._skip):\n",
    "            # Accumulate reward and repeat the same action\n",
    "            obs, reward, done, trunk, info = self.env.step(action)\n",
    "            total_reward += reward\n",
    "            if done:\n",
    "                break\n",
    "        return obs, total_reward, done, trunk, info\n",
    "\n",
    "\n",
    "class GrayScaleObservation(gym.ObservationWrapper):\n",
    "    def __init__(self, env):\n",
    "        super().__init__(env)\n",
    "        obs_shape = self.observation_space.shape[:2]\n",
    "        self.observation_space = Box(low=0, high=255, shape=obs_shape, dtype=np.uint8)\n",
    "\n",
    "    def permute_orientation(self, observation):\n",
    "        # permute [H, W, C] array to [C, H, W] tensor\n",
    "        observation = np.transpose(observation, (2, 0, 1))\n",
    "        observation = torch.tensor(observation.copy(), dtype=torch.float)\n",
    "        return observation\n",
    "\n",
    "    def observation(self, observation):\n",
    "        observation = self.permute_orientation(observation)\n",
    "        transform = T.Grayscale()\n",
    "        observation = transform(observation)\n",
    "        return observation\n",
    "\n",
    "\n",
    "class ResizeObservation(gym.ObservationWrapper):\n",
    "    def __init__(self, env, shape):\n",
    "        super().__init__(env)\n",
    "        if isinstance(shape, int):\n",
    "            self.shape = (shape, shape)\n",
    "        else:\n",
    "            self.shape = tuple(shape)\n",
    "\n",
    "        obs_shape = self.shape + self.observation_space.shape[2:]\n",
    "        self.observation_space = Box(low=0, high=255, shape=obs_shape, dtype=np.uint8)\n",
    "\n",
    "    def observation(self, observation):\n",
    "        transforms = T.Compose(\n",
    "            [T.Resize(self.shape, antialias=True), T.Normalize(0, 255)]\n",
    "        )\n",
    "        observation = transforms(observation).squeeze(0)\n",
    "        return observation\n",
    "\n",
    "\n",
    "# Apply Wrappers to environment\n",
    "env = SkipFrame(env, skip=4)\n",
    "env = GrayScaleObservation(env)\n",
    "env = ResizeObservation(env, shape=84)\n",
    "if gym.__version__ < '0.26':\n",
    "    env = FrameStack(env, num_stack=4, new_step_api=True)\n",
    "else:\n",
    "    env = FrameStack(env, num_stack=4)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "class Mario:\n",
    "    def __init__(self, state_dim, action_dim, save_dir, learning_rate=0.001, gamma=0.99):\n",
    "        self.state_dim = state_dim\n",
    "        self.action_dim = action_dim\n",
    "        self.save_dir = Path(save_dir)\n",
    "        self.gamma = gamma\n",
    "\n",
    "        self.device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        self.net = MarioNet(self.state_dim, self.action_dim).float().to(self.device)\n",
    "\n",
    "        self.exploration_rate = 1\n",
    "        self.exploration_rate_decay = 0.99999975\n",
    "        self.exploration_rate_min = 0.1\n",
    "        self.curr_step = 0\n",
    "\n",
    "        self.optimizer = torch.optim.Adam(self.net.parameters(), lr=learning_rate)\n",
    "        self.loss_fn = torch.nn.SmoothL1Loss()\n",
    "\n",
    "    def act(self, state):\n",
    "        if np.random.rand() < self.exploration_rate:\n",
    "            action_idx = np.random.randint(self.action_dim)\n",
    "        else:\n",
    "            state = state[0].__array__() if isinstance(state, tuple) else state.__array__()\n",
    "            state = torch.tensor(state, device=self.device).unsqueeze(0)\n",
    "            action_values = self.net(state, model=\"online\")\n",
    "            action_idx = torch.argmax(action_values, axis=1).item()\n",
    "            \n",
    "        self.exploration_rate *= self.exploration_rate_decay\n",
    "        self.exploration_rate = max(self.exploration_rate_min, self.exploration_rate)\n",
    "        self.curr_step += 1\n",
    "        return action_idx\n",
    "    \n",
    "    def update_q_values(self, state, action, next_state, reward, done):\n",
    "\n",
    "        def first_if_tuple(x):\n",
    "            return x[0] if isinstance(x, tuple) else x\n",
    "        state = first_if_tuple(state).__array__()\n",
    "        next_state = first_if_tuple(next_state).__array__()\n",
    "        \n",
    "        # Convert to tensors\n",
    "        state_tensor = torch.tensor(state).to(self.device)\n",
    "        next_state_tensor = torch.tensor(next_state).to(self.device)\n",
    "        action_tensor = torch.tensor([action]).long().to(self.device)  # actions are typically long type\n",
    "        reward_tensor = torch.tensor([reward]).to(self.device)\n",
    "        done_tensor = torch.tensor([done]).to(self.device)\n",
    "        done_float_tensor = done_tensor.float()\n",
    "\n",
    "        # Specify 'online' when calling the forward method of MarioNet\n",
    "        curr_Q = self.net(state_tensor.unsqueeze(0), 'online').gather(1, action_tensor.unsqueeze(1)).squeeze(1)\n",
    "        next_Q = self.net(next_state_tensor.unsqueeze(0), 'online').max(1)[0].detach()\n",
    "        expected_Q = reward_tensor + (1 - done_float_tensor) * self.gamma * next_Q\n",
    "\n",
    "        # Compute loss\n",
    "        loss = self.loss_fn(curr_Q, expected_Q)\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "        return loss.item()\n",
    "    \n",
    "    def save(self):\n",
    "        save_path = self.save_dir / f\"mario_net.chkpt\"\n",
    "        torch.save(\n",
    "            dict(model=self.net.state_dict(), exploration_rate=self.exploration_rate),\n",
    "            save_path,\n",
    "        )\n",
    "        print(f\"MarioNet saved to {save_path} at step {self.curr_step}\")\n",
    "    \n",
    "\n",
    "    \n",
    "class MarioNet(nn.Module):\n",
    "    \"\"\"\n",
    "    Structure: input -> (conv2d + relu) x 3 -> flatten -> (dense + relu) x 2 -> output\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, input_dim, output_dim):\n",
    "        super(MarioNet, self).__init__()\n",
    "        c, h, w = input_dim\n",
    "        \n",
    "        expected_height, expected_width = 84, 84\n",
    "        if h != expected_height or w != expected_width:\n",
    "            raise ValueError(f\"Expecting input dimensions: {expected_height}x{expected_width}, got: {h}x{w}\")\n",
    "\n",
    "        self.online = self.create_cnn_architecture(c, output_dim)\n",
    "        self.target = self.create_cnn_architecture(c, output_dim)\n",
    "        \n",
    "        self._update_target_network()\n",
    "\n",
    "    def forward(self, input, model=\"online\"):\n",
    "        \"\"\"Forward pass through the specified model: online or target.\"\"\"\n",
    "        if model not in [\"online\", \"target\"]:\n",
    "            raise ValueError(f\"Model type '{model}' is not valid. Choose 'online' or 'target'.\")\n",
    "        return getattr(self, model)(input)\n",
    "    \n",
    "    def create_cnn_architecture(self, input_channels, output_dim):\n",
    "        \"\"\"Constructs the CNN architecture.\"\"\"\n",
    "        return nn.Sequential(\n",
    "            nn.Conv2d(in_channels=input_channels, out_channels=32, kernel_size=8, stride=4),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(32, 64, kernel_size=4, stride=2),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(64, 64, kernel_size=3, stride=1),\n",
    "            nn.ReLU(),\n",
    "            nn.Flatten(),\n",
    "            nn.Linear(3136, 512),  # 3136 = 64 * 7 * 7, assuming input size 84x84\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(512, output_dim)\n",
    "        )\n",
    "\n",
    "    def _update_target_network(self):\n",
    "        \"\"\"Updates target network weights to match the online network and freezes target updates.\"\"\"\n",
    "        self.target.load_state_dict(self.online.state_dict())\n",
    "        for param in self.target.parameters():\n",
    "            param.requires_grad = False\n",
    "    \n",
    "\n",
    "class MetricLogger:\n",
    "    def __init__(self, save_dir):\n",
    "        self.save_dir = Path(save_dir)\n",
    "        self.ensure_dir_exists(self.save_dir)\n",
    "        self.initialize_log_files()\n",
    "\n",
    "        # History metrics\n",
    "        self.reset_history_metrics()\n",
    "\n",
    "        # Timing\n",
    "        self.record_time = time.time()\n",
    "\n",
    "    def ensure_dir_exists(self, dir_path):\n",
    "        dir_path.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "    def initialize_log_files(self):\n",
    "        self.save_log = self.save_dir / \"log\"\n",
    "        header = (\"{:<8}{:<8}{:<10}{:<15}\"\n",
    "                  \"{:<15}{:<15}{:<15}{:<15}{:<20}\\n\").format(\n",
    "            'Episode', 'Step', 'Epsilon', 'MeanReward',\n",
    "            'MeanLength', 'MeanLoss', 'MeanQValue', 'TimeDelta', 'Time')\n",
    "        with open(self.save_log, \"w\") as f:\n",
    "            f.write(header)\n",
    "\n",
    "        self.file_paths = {\n",
    "            'reward': \"reward_plot.jpg\",\n",
    "            'length': \"length_plot.jpg\",\n",
    "            'loss': \"loss_plot.jpg\",\n",
    "            'q_value': \"q_plot.jpg\"\n",
    "        }\n",
    "        for key in self.file_paths.keys():\n",
    "            self.file_paths[key] = self.save_dir / self.file_paths[key]\n",
    "\n",
    "    def reset_history_metrics(self):\n",
    "        self.ep_rewards = []\n",
    "        self.ep_lengths = []\n",
    "        self.ep_avg_losses = []\n",
    "        \n",
    "        self.moving_avg_ep_rewards = []\n",
    "        self.moving_avg_ep_lengths = []\n",
    "        self.moving_avg_ep_avg_losses = []\n",
    "\n",
    "        self.init_episode()\n",
    "    \n",
    "    def init_episode(self):\n",
    "        self.curr_ep_reward = 0.0\n",
    "        self.curr_ep_length = 0\n",
    "        self.curr_ep_loss = 0.0\n",
    "        self.curr_ep_loss_count = 0  # Renamed for clarity\n",
    "\n",
    "    def log_step(self, reward, loss, _):\n",
    "        self.curr_ep_reward += reward\n",
    "        self.curr_ep_length += 1\n",
    "        if loss is not None:\n",
    "            self.curr_ep_loss += loss\n",
    "            self.curr_ep_loss_count += 1  \n",
    "\n",
    "    def log_episode(self):\n",
    "        avg_loss = (self.curr_ep_loss / self.curr_ep_loss_count \n",
    "                    if self.curr_ep_loss_count else 0)\n",
    "        self.ep_rewards.append(self.curr_ep_reward)\n",
    "        self.ep_lengths.append(self.curr_ep_length)\n",
    "        self.ep_avg_losses.append(avg_loss)\n",
    "        \n",
    "        self.init_episode()\n",
    "\n",
    "    def compute_moving_averages(self):\n",
    "        for metric in ['ep_rewards', 'ep_lengths', 'ep_avg_losses']:\n",
    "            mean_value = np.round(np.mean(getattr(self, metric)[-100:]), 3)\n",
    "            moving_avg_attr = 'moving_avg_' + metric\n",
    "            getattr(self, moving_avg_attr).append(mean_value)\n",
    "\n",
    "    def record(self, episode, epsilon, step):\n",
    "        self.compute_moving_averages()\n",
    "        time_since_last_record = np.round(time.time() - self.record_time, 3)\n",
    "        self.record_time = time.time()\n",
    "        current_time_str = datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%S')\n",
    "\n",
    "        log_msg = (f\"{episode:<8d}{step:<8d}{epsilon:<10.3f}\"\n",
    "                   f\"{self.moving_avg_ep_rewards[-1]:<15.3f}\"\n",
    "                   f\"{self.moving_avg_ep_lengths[-1]:<15.3f}\"\n",
    "                   f\"{self.moving_avg_ep_avg_losses[-1]:<15.3f}\"\n",
    "                   f\"{time_since_last_record:<15.3f}{current_time_str:>20}\\n\")\n",
    "        with open(self.save_log, \"a\") as f:\n",
    "            f.write(log_msg)\n",
    "\n",
    "        print_message = (f\"Episode {episode} - \"\n",
    "                     f\"Step {step} - \"\n",
    "                     f\"Epsilon {epsilon:.3f} - \"\n",
    "                     f\"Mean Reward {self.moving_avg_ep_rewards[-1]:.3f} - \"\n",
    "                     f\"Mean Length {self.moving_avg_ep_lengths[-1]:.3f} - \"\n",
    "                     f\"Mean Loss {self.moving_avg_ep_avg_losses[-1]:.3f} - \"\n",
    "                     f\"Time Delta {time_since_last_record:.3f} - \"\n",
    "                     f\"Time {current_time_str}\")\n",
    "    \n",
    "        print(print_message)\n",
    "        if episode == episodes - 1:  # Check if it's the last episode\n",
    "            self.plot_final_rewards_graph()\n",
    "            \n",
    "    def plot_final_rewards_graph(self):\n",
    "        plt.figure()\n",
    "        plt.plot(self.moving_avg_ep_rewards, label='Moving Avg Rewards')\n",
    "        plt.title('Moving Average of Rewards')\n",
    "        plt.xlabel('Episodes')\n",
    "        plt.ylabel('Rewards')\n",
    "        plt.legend()\n",
    "        plt.show()  t\n",
    "\n",
    "# Example Usage\n",
    "logger = MetricLogger(\"./logs\")\n",
    "\n",
    "\n",
    "use_cuda = torch.cuda.is_available()\n",
    "print(f\"Using CUDA: {use_cuda}\")\n",
    "print()\n",
    "\n",
    "save_dir = Path(\"Mario_Q-Learning_checkpoints\") / datetime.datetime.now().strftime(\"%Y-%m-%dT%H-%M-%S\")\n",
    "save_dir.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "mario = Mario(state_dim=(4, 84, 84), action_dim=env.action_space.n, save_dir=save_dir)\n",
    "\n",
    "logger = MetricLogger(save_dir)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d7a547a-8c75-4049-b312-63288e07b018",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5968ee05-526c-4ed2-b925-d9924c5a4beb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Game Terminated: No Flag\tReward: 1608.0, Coins: 1\n",
      "Episode 0 - Step 373 - Epsilon 1.000 - Mean Reward 1608.000 - Mean Length 373.000 - Mean Loss 11.587 - Time Delta 3.814 - Time 2024-03-10T15:33:50\n",
      "Game Terminated: No Flag\tReward: 1686.0, Coins: 1\n",
      "Game Terminated: No Flag\tReward: 231.0, Coins: 1\n",
      "Game Terminated: No Flag\tReward: 1000.0, Coins: 1\n",
      "Game Terminated: No Flag\tReward: 238.0, Coins: 1\n",
      "Game Terminated: No Flag\tReward: 768.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 760.0, Coins: 1\n",
      "Game Terminated: No Flag\tReward: 585.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 607.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 1627.0, Coins: 2\n",
      "Game Terminated: No Flag\tReward: 222.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 946.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 884.0, Coins: 1\n",
      "Game Terminated: No Flag\tReward: 779.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 231.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 671.0, Coins: 1\n",
      "Game Terminated: No Flag\tReward: 961.0, Coins: 1\n",
      "Game Terminated: No Flag\tReward: 994.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 237.0, Coins: 1\n",
      "Game Terminated: No Flag\tReward: 1294.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 666.0, Coins: 1\n",
      "Episode 20 - Step 4896 - Epsilon 0.999 - Mean Reward 809.286 - Mean Length 233.143 - Mean Loss 14.267 - Time Delta 54.637 - Time 2024-03-10T15:34:44\n",
      "Game Terminated: No Flag\tReward: 618.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 766.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 238.0, Coins: 1\n",
      "Game Terminated: No Flag\tReward: 238.0, Coins: 1\n",
      "Game Terminated: No Flag\tReward: 596.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 237.0, Coins: 1\n",
      "Game Terminated: No Flag\tReward: 709.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 231.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 802.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 753.0, Coins: 2\n",
      "Game Terminated: No Flag\tReward: 603.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 787.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 688.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 752.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 664.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 231.0, Coins: 0\n",
      "Game Terminated: No Flag\tReward: 696.0, Coins: 1\n",
      "Game Terminated: No Flag\tReward: 2173.0, Coins: 2\n",
      "Game Terminated: No Flag\tReward: 744.0, Coins: 0\n",
      "Episode 39 - Step 9497 - Epsilon 0.998 - Mean Reward 738.025 - Mean Length 237.425 - Mean Loss 11.146 - Time Delta 57.792 - Time 2024-03-10T15:35:42\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# def potential(info):\n",
    "#     # Example potential based on Mario's x-position to encourage rightward progress\n",
    "#     # Assuming 'x_pos' is a key in the 'info' dict that tracks Mario's position\n",
    "#     return info.get('x_pos', 0)\n",
    "    \n",
    "\n",
    "episodes = 40\n",
    "for e in range(episodes):\n",
    "    state = env.reset()\n",
    "    total_reward = 0\n",
    "    while True:\n",
    "        # Run agent on the state\n",
    "        action = mario.act(state)\n",
    "        \n",
    "        # Agent performs action\n",
    "        next_state, reward, done, trunc, info = env.step(action)\n",
    "        \n",
    "        # Accumulate reward with any additional environmental factors, such as coins\n",
    "        coins_collected = info.get('coins', 0)\n",
    "        reward += coins_collected\n",
    "        total_reward += reward\n",
    "\n",
    "        # Q-learning update\n",
    "        loss = mario.update_q_values(state, action, next_state, reward, done)\n",
    "\n",
    "        # Logging\n",
    "        logger.log_step(reward, loss, None)  # q value (None) is not used in standard Q-learning\n",
    "\n",
    "        # Update state\n",
    "        state = next_state\n",
    "\n",
    "        # Check if end of game\n",
    "        if done or info.get(\"flag_get\", False):  # Ensure 'flag_get' key exists with .get method\n",
    "            if info.get(\"flag_get\", False):\n",
    "                print(f\"Flag Gotten\\tReward: {total_reward}\")\n",
    "            if done:\n",
    "                print(f\"Game Terminated: No Flag\\tReward: {total_reward}, Coins: {coins_collected}\")\n",
    "            break\n",
    "\n",
    "    logger.log_episode()\n",
    "\n",
    "    if (e % 20 == 0) or (e == episodes - 1):\n",
    "        logger.record(episode=e, epsilon=mario.exploration_rate, step=mario.curr_step)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53db6aee-3ae9-4b61-b9b6-43ebd91be382",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}