AMPER.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Importing shit"
      ],
      "metadata": {
        "id": "NGqwi4uzO4Bw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from collections import deque\n",
        "import math\n",
        "import random\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "BWF8fArZOz1s"
      },
      "execution_count": 104,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Environment Setup"
      ],
      "metadata": {
        "id": "qEXzwRUkO1GV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class NSGridEnv(gym.Env):\n",
        "    def __init__(self, grid_size=5, change_interval=50):\n",
        "        super(NSGridEnv, self).__init__()\n",
        "        self.grid_size = grid_size\n",
        "        self.action_space = spaces.Discrete(4)\n",
        "        self.observation_space = spaces.Box(low=0, high=grid_size - 1, shape=(2,), dtype=np.int32)\n",
        "        self.state = None\n",
        "        self.steps = 0\n",
        "        self.change_interval = change_interval\n",
        "        self.goal_position = self._rand_goal()\n",
        "\n",
        "    def _rand_goal(self):\n",
        "        while True:\n",
        "            goal = np.array([\n",
        "                random.randint(0, self.grid_size - 1),\n",
        "                random.randint(0, self.grid_size - 1)\n",
        "            ])\n",
        "            if not np.array_equal(goal, np.array([self.grid_size // 2, self.grid_size // 2])):\n",
        "                return goal\n",
        "\n",
        "    def reset(self):\n",
        "        self.state = np.array([self.grid_size // 2, self.grid_size // 2])\n",
        "        self.steps = 0\n",
        "        return self.state.copy()\n",
        "\n",
        "    def step(self, action):\n",
        "        self.steps += 1\n",
        "        if self.steps % self.change_interval == 0:\n",
        "            self.goal_position = self._rand_goal()\n",
        "        if action == 0 and self.state[1] < self.grid_size - 1:\n",
        "            self.state[1] += 1\n",
        "        elif action == 1 and self.state[1] > 0:\n",
        "            self.state[1] -= 1\n",
        "        elif action == 2 and self.state[0] > 0:\n",
        "            self.state[0] -= 1\n",
        "        elif action == 3 and self.state[0] < self.grid_size - 1:\n",
        "            self.state[0] += 1\n",
        "        done = np.array_equal(self.state, self.goal_position)\n",
        "        reward = 1 if done else -0.1\n",
        "        return self.state.copy(), reward, done, {}\n",
        "\n",
        "    def render(self, mode='human'):\n",
        "        grid = np.full((self.grid_size, self.grid_size), '_', dtype='<U1')\n",
        "        grid[self.state[1], self.state[0]] = 'A'\n",
        "        grid[self.goal_position[1], self.goal_position[0]] = 'G'\n",
        "        print('\\n'.join([' '.join(row) for row in grid[::-1]]))\n",
        "        print()"
      ],
      "metadata": {
        "id": "agGDWmVAKtSz"
      },
      "execution_count": 108,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Agent Implementation\n",
        "## Q-Network"
      ],
      "metadata": {
        "id": "GBL5wk4SPAgD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class QNet(nn.Module):\n",
        "    def __init__(self, state_size, action_size, mem_size):\n",
        "        super(QNet, self).__init__()\n",
        "        self.fc1 = nn.Linear(state_size + mem_size, 128)\n",
        "        self.fc2 = nn.Linear(128, 64)\n",
        "        self.fc3 = nn.Linear(64, action_size)\n",
        "\n",
        "    def forward(self, state, memory):\n",
        "        x = torch.cat((state, memory), dim=1)\n",
        "        x = torch.relu(self.fc1(x))\n",
        "        x = torch.relu(self.fc2(x))\n",
        "        return self.fc3(x)"
      ],
      "metadata": {
        "id": "MYnhvz0TKv_O"
      },
      "execution_count": 109,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## MANN"
      ],
      "metadata": {
        "id": "0bk3Ep9PPJJ5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class MemMod:\n",
        "    def __init__(self, key_size, val_size, mem_capacity=1000):\n",
        "        self.mem_capacity = mem_capacity\n",
        "        self.keys = torch.zeros((mem_capacity, key_size))\n",
        "        self.values = torch.zeros((mem_capacity, val_size))\n",
        "        self.write_idx = 0\n",
        "\n",
        "    def wr(self, key, value):\n",
        "        idx = self.write_idx % self.mem_capacity\n",
        "        self.keys[idx] = key\n",
        "        self.values[idx] = value\n",
        "        self.write_idx += 1\n",
        "\n",
        "    def rd(self, query_key):\n",
        "        if self.write_idx == 0:\n",
        "            return torch.zeros(self.values.shape[1])\n",
        "        similarities = torch.nn.functional.cosine_similarity(query_key, self.keys[:self.write_idx], dim=1)\n",
        "        idx = torch.argmax(similarities).item()\n",
        "        return self.values[idx]"
      ],
      "metadata": {
        "id": "8RxGSFfRKxJM"
      },
      "execution_count": 110,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Prioritized Replay Buffer"
      ],
      "metadata": {
        "id": "r986pzqWPMNv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class PRBuffer:\n",
        "    def __init__(self, capacity, alpha=0.6):\n",
        "        self.capacity = capacity\n",
        "        self.buffer = []\n",
        "        self.pos = 0\n",
        "        self.priorities = np.zeros((capacity,), dtype=np.float32)\n",
        "        self.alpha = alpha\n",
        "\n",
        "    def add_exp(self, error, sample):\n",
        "        max_priority = self.priorities.max() if self.buffer else 1.0\n",
        "        if len(self.buffer) < self.capacity:\n",
        "            self.buffer.append(sample)\n",
        "        else:\n",
        "            self.buffer[self.pos] = sample\n",
        "        self.priorities[self.pos] = max_priority\n",
        "        self.pos = (self.pos + 1) % self.capacity\n",
        "\n",
        "    def samp(self, batch_size, beta=0.4):\n",
        "        if len(self.buffer) == self.capacity:\n",
        "            prios = self.priorities\n",
        "        else:\n",
        "            prios = self.priorities[:len(self.buffer)]\n",
        "        probs = prios ** self.alpha\n",
        "        probs /= probs.sum()\n",
        "        indices = np.random.choice(len(self.buffer), batch_size, p=probs)\n",
        "        samples = [self.buffer[idx] for idx in indices]\n",
        "        total = len(self.buffer)\n",
        "        weights = (total * probs[indices]) ** (-beta)\n",
        "        weights /= weights.max()\n",
        "        weights = np.array(weights, dtype=np.float32)\n",
        "        return samples, indices, weights\n",
        "\n",
        "    def upd_prio(self, indices, errors):\n",
        "        self.priorities[indices] = np.abs(errors) + 1e-5"
      ],
      "metadata": {
        "id": "gh25zkjeKykp"
      },
      "execution_count": 111,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Agent Class"
      ],
      "metadata": {
        "id": "gOWZ7I11POP8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class AgentDPERMem:\n",
        "    def __init__(self, state_size, action_size, mem_size=2, buffer_capacity=1000):\n",
        "        self.state_size = state_size\n",
        "        self.action_size = action_size\n",
        "        self.mem_size = mem_size\n",
        "        self.mem_mod = MemMod(key_size=state_size, val_size=mem_size)\n",
        "        self.q_net = QNet(state_size, action_size, mem_size)\n",
        "        self.target_net = QNet(state_size, action_size, mem_size)\n",
        "        self.target_net.load_state_dict(self.q_net.state_dict())\n",
        "        self.optimizer = optim.Adam(self.q_net.parameters(), lr=0.001)\n",
        "        self.buffer_capacity = buffer_capacity\n",
        "        self.buffer = PRBuffer(capacity=buffer_capacity)\n",
        "        self.steps_done = 0\n",
        "        self.epsilon = 1.0\n",
        "        self.eps_min = 0.1\n",
        "        self.eps_decay = 0.995\n",
        "        self.gamma = 0.99\n",
        "        self.batch_size = 32\n",
        "        self.update_target_every = 100\n",
        "        self.beta = 0.4\n",
        "        self.beta_inc = 0.001\n",
        "        self.alpha = 0.6\n",
        "\n",
        "    def sel_act(self, state, memory):\n",
        "        self.epsilon = max(self.epsilon * self.eps_decay, self.eps_min)\n",
        "        if random.random() < self.epsilon:\n",
        "            return random.randint(0, self.action_size - 1)\n",
        "        else:\n",
        "            with torch.no_grad():\n",
        "                q_values = self.q_net(state, memory)\n",
        "                return torch.argmax(q_values).item()\n",
        "\n",
        "    def mem_exp(self, error, experience):\n",
        "        self.buffer.add_exp(error, experience)\n",
        "\n",
        "    def repl(self):\n",
        "        if len(self.buffer.buffer) < self.batch_size:\n",
        "            return None\n",
        "        self.beta = min(1.0, self.beta + self.beta_inc)\n",
        "        samples, indices, weights = self.buffer.samp(self.batch_size, self.beta)\n",
        "        batch = list(zip(*samples))\n",
        "        states = torch.FloatTensor(np.vstack(batch[0]))\n",
        "        actions = torch.LongTensor(batch[1]).unsqueeze(1)\n",
        "        rewards = torch.FloatTensor(batch[2]).unsqueeze(1)\n",
        "        next_states = torch.FloatTensor(np.vstack(batch[3]))\n",
        "        dones = torch.FloatTensor(batch[4]).unsqueeze(1)\n",
        "        memory = torch.zeros((self.batch_size, self.mem_size))\n",
        "        for i in range(self.batch_size):\n",
        "            key = states[i]\n",
        "            memory[i] = self.mem_mod.rd(key)\n",
        "        q_values = self.q_net(states, memory).gather(1, actions)\n",
        "        with torch.no_grad():\n",
        "            next_memory = torch.zeros((self.batch_size, self.mem_size))\n",
        "            for i in range(self.batch_size):\n",
        "                key = next_states[i]\n",
        "                next_memory[i] = self.mem_mod.rd(key)\n",
        "            next_q_values = self.target_net(next_states, next_memory).max(1)[0].unsqueeze(1)\n",
        "            expected_q_values = rewards + (1 - dones) * self.gamma * next_q_values\n",
        "        td_errors = expected_q_values - q_values\n",
        "        weights_tensor = torch.FloatTensor(weights).unsqueeze(1)\n",
        "        loss = (weights_tensor * td_errors.pow(2)).mean()\n",
        "        self.optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        self.optimizer.step()\n",
        "        errors = td_errors.detach().squeeze().numpy()\n",
        "        self.buffer.upd_prio(indices, errors)\n",
        "        if self.steps_done % self.update_target_every == 0:\n",
        "            self.target_net.load_state_dict(self.q_net.state_dict())\n",
        "        return loss.item()\n",
        "\n",
        "    def upd_mem(self, state, action, reward, next_state):\n",
        "        key = torch.FloatTensor(state)\n",
        "        value = torch.FloatTensor(next_state - state)\n",
        "        self.mem_mod.wr(key, value)"
      ],
      "metadata": {
        "id": "FTq31LOMK01h"
      },
      "execution_count": 112,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Training shit"
      ],
      "metadata": {
        "id": "wT5DyvpmPRcJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "env = NSGridEnv()\n",
        "agent = AgentDPERMem(state_size=2, action_size=4, mem_size=2, buffer_capacity=1000)\n",
        "rewards_history = []\n",
        "losses = []\n",
        "epsilon_values = []\n",
        "num_episodes = 500\n",
        "\n",
        "for episode in range(num_episodes):\n",
        "    state = env.reset()\n",
        "    total_reward = 0\n",
        "    cumulative_loss = 0\n",
        "    loss_count = 0\n",
        "    done = False\n",
        "    while not done:\n",
        "        agent.steps_done += 1\n",
        "        state_tensor = torch.FloatTensor(state).unsqueeze(0)\n",
        "        memory = agent.mem_mod.rd(state_tensor[0]).unsqueeze(0)\n",
        "        action = agent.sel_act(state_tensor, memory)\n",
        "        next_state, reward, done, _ = env.step(action)\n",
        "        total_reward += reward\n",
        "        next_state_tensor = torch.FloatTensor(next_state).unsqueeze(0)\n",
        "        next_memory = agent.mem_mod.rd(next_state_tensor[0]).unsqueeze(0)\n",
        "        with torch.no_grad():\n",
        "            q_next = agent.target_net(next_state_tensor, next_memory).max(1)[0].item()\n",
        "            q_target = reward + agent.gamma * q_next * (1 - int(done))\n",
        "        q_current = agent.q_net(state_tensor, memory)[0][action].item()\n",
        "        error = q_target - q_current\n",
        "        agent.mem_exp(error, (state, action, reward, next_state, done))\n",
        "        agent.upd_mem(state, action, reward, next_state)\n",
        "        loss = agent.repl()\n",
        "        if loss is not None:\n",
        "            cumulative_loss += loss\n",
        "            loss_count += 1\n",
        "        state = next_state\n",
        "    rewards_history.append(total_reward)\n",
        "    epsilon_values.append(agent.epsilon)\n",
        "    if loss_count > 0:\n",
        "        average_loss = cumulative_loss / loss_count\n",
        "    else:\n",
        "        average_loss = 0\n",
        "    losses.append(average_loss)\n",
        "    if (episode + 1) % 50 == 0:\n",
        "        print(f'Episode {episode+1}/{num_episodes}, Total Reward: {total_reward:.2f}, Epsilon: {agent.epsilon:.4f}')\n",
        "print(\"Training completed.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rw3bvvf8K2lh",
        "outputId": "ba886427-8992-44ee-a3f6-252e150a4076"
      },
      "execution_count": 113,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Episode 50/500, Total Reward: 0.90, Epsilon: 0.1474\n",
            "Episode 100/500, Total Reward: 0.50, Epsilon: 0.1000\n",
            "Episode 150/500, Total Reward: 0.90, Epsilon: 0.1000\n",
            "Episode 200/500, Total Reward: 0.90, Epsilon: 0.1000\n",
            "Episode 250/500, Total Reward: 0.90, Epsilon: 0.1000\n",
            "Episode 300/500, Total Reward: 0.90, Epsilon: 0.1000\n",
            "Episode 350/500, Total Reward: 0.90, Epsilon: 0.1000\n",
            "Episode 400/500, Total Reward: 0.70, Epsilon: 0.1000\n",
            "Episode 450/500, Total Reward: 0.90, Epsilon: 0.1000\n",
            "Episode 500/500, Total Reward: 0.50, Epsilon: 0.1000\n",
            "Training completed.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Plotting Performance"
      ],
      "metadata": {
        "id": "MLBZ-TzFPWQd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def moving_avg(data, window_size):\n",
        "    return np.convolve(data, np.ones(window_size)/window_size, mode='valid')\n",
        "\n",
        "window_size = 10\n",
        "rewards_smoothed = moving_avg(rewards_history, window_size)\n",
        "episodes = np.arange(len(rewards_smoothed))\n",
        "\n",
        "fig, axs = plt.subplots(3, 1, figsize=(12, 18))\n",
        "\n",
        "axs[0].plot(rewards_history, color='blue', alpha=0.3, label='Total Reward')\n",
        "axs[0].plot(episodes + window_size - 1, rewards_smoothed, color='blue', label='Smoothed Reward')\n",
        "axs[0].set_title('Total Reward per Episode')\n",
        "axs[0].set_xlabel('Episode')\n",
        "axs[0].set_ylabel('Total Reward')\n",
        "axs[0].legend()\n",
        "axs[0].grid(True)\n",
        "\n",
        "axs[1].plot(losses, color='red')\n",
        "axs[1].set_title('Average Loss per Episode')\n",
        "axs[1].set_xlabel('Episode')\n",
        "axs[1].set_ylabel('Loss')\n",
        "axs[1].grid(True)\n",
        "\n",
        "axs[2].plot(epsilon_values, color='green')\n",
        "axs[2].set_title('Exploration Rate (Epsilon) over Episodes')\n",
        "axs[2].set_xlabel('Episode')\n",
        "axs[2].set_ylabel('Epsilon')\n",
        "axs[2].grid(True)\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "C0gA0bVXLr9L",
        "outputId": "d26ff426-d6be-4462-f84b-6932617960a6"
      },
      "execution_count": 114,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x1800 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Visualizing Policy"
      ],
      "metadata": {
        "id": "H7GJZsZwPmAT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def viz_policy(agent, grid_size):\n",
        "    policy_grid = np.empty((grid_size, grid_size), dtype='<U2')\n",
        "    action_symbols = ['↑', '↓', '←', '→']\n",
        "    for y in range(grid_size):\n",
        "        for x in range(grid_size):\n",
        "            state = torch.FloatTensor([x, y]).unsqueeze(0)\n",
        "            memory = agent.mem_mod.rd(state[0]).unsqueeze(0)\n",
        "            with torch.no_grad():\n",
        "                q_values = agent.q_net(state, memory)\n",
        "                action = torch.argmax(q_values).item()\n",
        "            policy_grid[y, x] = action_symbols[action]\n",
        "    print(\"Learned Policy:\")\n",
        "    for row in policy_grid[::-1]:\n",
        "        print(' '.join(row))\n",
        "\n",
        "viz_policy(agent, env.grid_size)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mrMLQRw4L0YA",
        "outputId": "cfb3ee13-da20-4312-dce1-962b19175bf5"
      },
      "execution_count": 116,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Learned Policy:\n",
            "→ → ↑ ← ←\n",
            "↑ ↑ ↑ ↑ ←\n",
            "↑ ↑ ↑ ↑ ←\n",
            "↑ ↑ ↑ ← ←\n",
            "↑ ↑ ↑ ← ←\n"
          ]
        }
      ]
    }
  ]
}