rl.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PROGRESS\n",
    "- try to make it faster. many functions run multiple times for no reason"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Imports Versioning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.29.1\n",
      "3.9.2\n",
      "2.4.1+cpu\n",
      "0.19.1+cpu\n",
      "2.4.1+cpu\n",
      "0.9.54\n",
      "1.26.4\n"
     ]
    }
   ],
   "source": [
    "import gymnasium as gym\n",
    "import matplotlib\n",
    "import torch\n",
    "import torchvision\n",
    "import torchaudio\n",
    "import pyautogui\n",
    "import numpy as np\n",
    "\n",
    "from collections import deque\n",
    "\n",
    "print(gym.__version__)          # 0.29.1\n",
    "print(matplotlib.__version__)   # 3.9.2\n",
    "print(torch.__version__)        # 2.4.1+cpu\n",
    "print(torchvision.__version__)  # 0.19.1+cpu\n",
    "print(torchaudio.__version__)   # 2.4.1+cpu\n",
    "print(pyautogui.__version__)    # 0.9.54\n",
    "print(np.__version__)           # 1.26.4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Preprocessing Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torchvision import transforms\n",
    "\n",
    "# Preprocess the frames (resize and convert to grayscale)\n",
    "def preprocess_frame(frame):\n",
    "    transform = transforms.Compose([\n",
    "        transforms.ToPILImage(),\n",
    "        transforms.Grayscale(),  # Convert to grayscale\n",
    "        transforms.Resize((84, 84)),  # Resize to 84x84\n",
    "        transforms.ToTensor(),  # Convert to tensor, will have shape [1, 84, 84]\n",
    "    ])\n",
    "    return transform(frame).squeeze(0)  # Remove the single channel dimension, resulting in [84, 84]\n",
    "\n",
    "\n",
    "# Stack 4 frames\n",
    "def stack_frames(frames):\n",
    "    return np.stack(frames, axis=0)  # Shape will be [4, 84, 84]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Initialise Environment, Model & Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from DQNCNN import DQNCNN\n",
    "from DQNAgent import DQNAgent\n",
    "from WASDEnv import WinFormsGameEnv\n",
    "\n",
    "env = WinFormsGameEnv()\n",
    "\n",
    "STACK_SIZE = 1 # amount of frames stacked\n",
    "ACTION_SIZE = env.action_space.n\n",
    "\n",
    "deep_q_learning_model = DQNCNN(action_size=ACTION_SIZE, stack_size=STACK_SIZE)\n",
    "agent = DQNAgent(DQNCNN=deep_q_learning_model, action_size=ACTION_SIZE)\n",
    "env.action_space.n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Training Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode: 1/1, Total Reward: 0\n"
     ]
    }
   ],
   "source": [
    "# Stack size for CNN input (4 stacked frames)\n",
    "stack_size = 1\n",
    "\n",
    "saved_frame = None\n",
    "\n",
    "# Training loop\n",
    "num_episodes = 1\n",
    "for e in range(num_episodes):\n",
    "    state_stack = deque(maxlen=stack_size)\n",
    "    state = env.reset()\n",
    "    \n",
    "    # Initialize frame stack with initial frame\n",
    "    frame = preprocess_frame(env.render())\n",
    "    for _ in range(stack_size):\n",
    "        state_stack.append(frame)\n",
    "\n",
    "\n",
    "    saved_frame = frame\n",
    "\n",
    "    done = False\n",
    "    total_reward = 0\n",
    "    while not done:\n",
    "        state = stack_frames(state_stack)\n",
    "        saved_frame = state\n",
    "        # Choose an action\n",
    "        action = agent.select_action(state)\n",
    "        \n",
    "        # Perform action\n",
    "        next_state, reward, done, _, _ = env.step(action)\n",
    "        \n",
    "        # Process next state (frame) and add to the stack\n",
    "        next_frame = preprocess_frame(env.render())\n",
    "        state_stack.append(next_frame)\n",
    "        next_state_stack = stack_frames(state_stack)\n",
    "\n",
    "        # Store experience in replay memory\n",
    "        agent.memory.add((state, action, reward, next_state_stack, done))\n",
    "        \n",
    "        # Train the agent with experience replay\n",
    "        agent.replay()\n",
    "\n",
    "        # Update the state\n",
    "        state_stack = state_stack\n",
    "\n",
    "        total_reward += reward\n",
    "        \n",
    "        # Periodically update target network\n",
    "        if e % agent.update_frequency == 0:\n",
    "            agent.update_target_network()\n",
    "\n",
    "    print(f\"Episode: {e+1}/{num_episodes}, Total Reward: {total_reward}\")\n",
    "\n",
    "env.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. Save Model Weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "# Assuming `agent` is your trained model and `path_to_save` is the file path\n",
    "torch.save(agent.q_network.state_dict(), './q_network_WASD.pth')\n",
    "torch.save(agent.target_network.state_dict(), './target_network_WASD.pth')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. Load Model Weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Kaan\\AppData\\Local\\Temp\\ipykernel_16432\\50916430.py:5: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  agent.q_network.load_state_dict(torch.load('./model/q_network_WASD_perfect.pth'))\n",
      "C:\\Users\\Kaan\\AppData\\Local\\Temp\\ipykernel_16432\\50916430.py:8: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  agent.target_network.load_state_dict(torch.load('./model/target_network_WASD_perfect.pth'))\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "DQNCNN(\n",
       "  (conv1): Conv2d(1, 64, kernel_size=(3, 3), stride=(2, 2))\n",
       "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (fc1): Linear(in_features=25600, out_features=512, bias=True)\n",
       "  (fc2): Linear(in_features=512, out_features=4, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "# Assuming `Agent` is your model class\n",
    "agent.q_network = DQNCNN(action_size=ACTION_SIZE, stack_size=STACK_SIZE)  # Initialize the model architecture\n",
    "agent.q_network.load_state_dict(torch.load('./model/q_network_WASD_perfect.pth'))\n",
    "\n",
    "agent.target_network = DQNCNN(action_size=ACTION_SIZE, stack_size=STACK_SIZE)  # Initialize the model architecture\n",
    "agent.target_network.load_state_dict(torch.load('./model/target_network_WASD_perfect.pth'))\n",
    "\n",
    "# Ensure the models are in evaluation mode\n",
    "agent.q_network.eval()\n",
    "agent.target_network.eval()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. Test Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actions per second (APS): 3.8966567083366894\n",
      "Test Episode: 1/1, Total Reward: 100\n",
      "avg score: 100.0\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt \n",
    "import time\n",
    "\n",
    "# Testing loop (after training)\n",
    "num_test_episodes = 1\n",
    "stack_size = 1\n",
    "all_rewards = 0\n",
    "MAX_SCORE= 100\n",
    "\n",
    "for e in range(num_test_episodes):\n",
    "    start_time = time.time() # start timer\n",
    "    state_stack = deque(maxlen=stack_size) # create stack for frames\n",
    "    state = env.reset() # get initial state\n",
    "    frame = preprocess_frame(state) # preprocess state/frame\n",
    "    for _ in range(stack_size): # fill frames\n",
    "        state_stack.append(frame)\n",
    "\n",
    "    done = False\n",
    "    total_reward = 0\n",
    "\n",
    "    while not done:\n",
    "        state = stack_frames(state_stack)\n",
    "\n",
    "        # Use the trained model to select an action (no exploration during testing)\n",
    "        action = agent.select_action(state, explore=False)  # No exploration in testing\n",
    "\n",
    "        # Perform the action in the environment\n",
    "        next_state, reward, done, _, _ = env.step(action)\n",
    "\n",
    "        # Process the next state (frame) and update the frame stack\n",
    "        next_frame = preprocess_frame(env.render())\n",
    "        state_stack.append(next_frame)\n",
    "\n",
    "        total_reward += reward\n",
    "\n",
    "        # Update the plot with the new frame\n",
    "        # plt.title(f\"Test Episode: {e + 1}/{num_test_episodes}, Total Reward: {total_reward}\")\n",
    "        # plt.pause(0.001)  # Short pause to allow plot to update\n",
    "        if total_reward == MAX_SCORE:\n",
    "            break\n",
    "    end_time = time.time()\n",
    "        # Calculate total time and actions per second (APS)\n",
    "    total_time = end_time - start_time\n",
    "    aps = MAX_SCORE / total_time\n",
    "    print(f\"Actions per second (APS): {aps}\")\n",
    "\n",
    "    print(f\"Test Episode: {e + 1}/{num_test_episodes}, Total Reward: {total_reward}\")\n",
    "    all_rewards += total_reward\n",
    "print(f'avg score: {all_rewards/num_test_episodes}')\n",
    "env.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8. Training Results\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "episodes = list(range(1, 130))\n",
    "training_results = [\n",
    "    0, 1, 1, 3, 2, 0, 2, 0, 1, 0, 2, 0, 0, 1, 2, 2, 0, 1, 0, 0, 1, 1, 2, 5, 4, 4, 0, 4, 0, 5, \n",
    "    3, 0, 0, 0, 6, 2, 1, 0, 0, 0, 3, 0, 2, 0, 2, 1, 1, 0, 0, 4, 3, 0, 4, 1, 0, 5, 9, 6, 13, 0, \n",
    "    20, 18, 8, 8, 11, 2, 12, 12, 0, 27, 15, 41, 19, 21, 14, 50, 15, 47, 85, 207, 484, 52, 304, \n",
    "    547, 53, 158, 271, 57, 52, 92, 98, 2, 64, 62, 13, 183, 448, 153, 33, 112, 133, 116, 104, 21, \n",
    "    88, 185, 646, 132, 310, 94, 96, 20, 139, 265, 18, 7, 52, 269, 38, 958, 307, 95, 312, 90, 234, \n",
    "    9, 45, 568, 531\n",
    "]\n",
    "\n",
    "\n",
    "# Create the plot\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.plot(episodes, training_results, label=\"Total Reward\", color=\"b\")\n",
    "\n",
    "plt.xlim([1, 129])\n",
    "\n",
    "# Adding titles and labels\n",
    "plt.title(\"Training Results: Total Reward per Episode\")\n",
    "plt.xlabel(\"Episode\")\n",
    "plt.ylabel(\"Total Reward\")\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9. Testing Results\n",
    "- The testing results were never ending. I decided to stop it myself at a score of 20000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Define the episodes and testing results\n",
    "episodes = [1, 2]\n",
    "testing_results = [20000, 20000]\n",
    "\n",
    "# Create the plot\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.plot(episodes, testing_results, label=\"Total Reward\", color=\"b\", marker='o')\n",
    "\n",
    "# Set the x-axis ticks with a step of 1.0\n",
    "plt.xticks(range(min(episodes), max(episodes) + 1, 1))\n",
    "\n",
    "# Set the y-axis limit slightly over 20000\n",
    "plt.ylim([0, 20500])\n",
    "\n",
    "# Adding titles and labels\n",
    "plt.title(\"Testing Results: Total Reward per Episode\")\n",
    "plt.xlabel(\"Episode\")\n",
    "plt.ylabel(\"Total Reward\")\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "\n",
    "# Display the plot\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agent Speed: 3.8fps"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}