diff --git a/.gitignore b/.gitignore
index 6276225..33e399a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 *.png
-*.h5
\ No newline at end of file
+*.h5
+*.pt
\ No newline at end of file
diff --git a/.ipynb_checkpoints/Test-checkpoint.ipynb b/.ipynb_checkpoints/Test-checkpoint.ipynb
new file mode 100644
index 0000000..dcbf104
--- /dev/null
+++ b/.ipynb_checkpoints/Test-checkpoint.ipynb
@@ -0,0 +1,353 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "5ebc5698-7678-4730-8bdb-26d39cc3969d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/piwalker/code/machine_learning/simple_crypto/venv/lib/python3.13/site-packages/pygame/pkgdata.py:25: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n",
+      "  from pkg_resources import resource_stream, resource_exists\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from pettingzoo.mpe import simple_reference_v3,simple_v3\n",
+    "import numpy as np\n",
+    "from IPython.display import clear_output\n",
+    "from IPython.core.debugger import set_trace\n",
+    "import matplotlib.pyplot as plt\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "c1eaeab6-4b9e-4b5c-8db2-bd79b3887413",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "max_frames = 5000000\n",
+    "batch_size = 5\n",
+    "learning_rate = 7e-4\n",
+    "gamma = 0.99\n",
+    "entropy_coef = 0.01\n",
+    "critic_coef = 0.5\n",
+    "no_of_workers = 16"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "5da2c091-9ac7-4142-803c-4e8b2b4c586e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "FloatTensor = torch.FloatTensor\n",
+    "LongTensor = torch.LongTensor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "04f39958-d3f8-4484-a7fd-97f7da05cd4b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Model(torch.nn.Module):\n",
+    "    def __init__(self, observation_space, action_space):\n",
+    "        super(Model, self).__init__()\n",
+    "        self.features = torch.nn.Sequential(\n",
+    "            torch.nn.Linear(observation_space, 32),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(32, 128),\n",
+    "            torch.nn.ReLU()\n",
+    "        )\n",
+    "\n",
+    "        self.critic = torch.nn.Sequential(\n",
+    "            torch.nn.Linear(128, 256),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(256, 1)\n",
+    "        )\n",
+    "\n",
+    "        self.actor = torch.nn.Sequential(\n",
+    "            torch.nn.Linear(128, 256),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(256, action_space),\n",
+    "            torch.nn.Softmax(dim=-1)\n",
+    "        )\n",
+    "    \n",
+    "    def forward(self, x):\n",
+    "        x = self.features(x)\n",
+    "        value = self.critic(x)\n",
+    "        actions = self.actor(x)\n",
+    "        return value, actions\n",
+    "\n",
+    "    def get_critic(self, x):\n",
+    "        x = self.features(x)\n",
+    "        return self.critic(x)\n",
+    "    \n",
+    "    def evaluate_action(self, state, action):\n",
+    "        value, actor_features = self.forward(state)\n",
+    "        dist = torch.distributions.Categorical(actor_features)\n",
+    "        log_probs = dist.log_prob(action).view(-1, 1)\n",
+    "        entropy = dist.entropy().mean()\n",
+    "\n",
+    "        return value, log_probs, entropy\n",
+    "    \n",
+    "    def act(self, state):\n",
+    "        value, actor_features = self.forward(state)\n",
+    "        dist = torch.distributions.Categorical(actor_features)\n",
+    "\n",
+    "        chosen_action = dist.sample()\n",
+    "        return chosen_action.item()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "58dcf7c9-6405-4d83-9ea5-bdebdd614db8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Memory(object):\n",
+    "    def __init__(self):\n",
+    "        self.states, self.actions, self.true_values = [], [], []\n",
+    "    \n",
+    "    def push(self, state, action, true_value):\n",
+    "        self.states.append(state)\n",
+    "        self.actions.append(action)\n",
+    "        self.true_values.append(true_value)\n",
+    "    \n",
+    "    def pop_all(self):\n",
+    "        states = torch.stack(self.states)\n",
+    "        actions = LongTensor(self.actions)\n",
+    "        true_values = FloatTensor(self.true_values).unsqueeze(1)\n",
+    "\n",
+    "        self.states, self.actions, self.true_values = [], [], []\n",
+    "        return states, actions, true_values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "4edd19f6-193e-4183-9eab-498f176b32a2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Worker(object):\n",
+    "    def __init__(self):\n",
+    "        self.env = simple_v3.parallel_env()\n",
+    "        self.episode_reward = 0\n",
+    "        self.state = FloatTensor(self.env.reset()[0][\"agent_0\"])\n",
+    "\n",
+    "    def get_batch(self):\n",
+    "        states, actions, rewards, dones = [], [], [], []\n",
+    "        for _ in range(batch_size):\n",
+    "            action = model.act(self.state.unsqueeze(0))\n",
+    "            actiondict = {}\n",
+    "            actiondict[\"agent_0\"] = action\n",
+    "            next_state, reward, terminations, truncations, _ = self.env.step(actiondict)\n",
+    "            self.episode_reward += reward[\"agent_0\"]\n",
+    "            states.append(self.state)\n",
+    "            actions.append(action)\n",
+    "            rewards.append(reward[\"agent_0\"])\n",
+    "            done = False if \"agent_0\" in terminations else True\n",
+    "            dones.append(done)\n",
+    "\n",
+    "            if done:\n",
+    "                self.state = FloatTensor(self.env.reset()[0][\"agent_0\"])\n",
+    "                data['episode_rewards'].append(self.episode_reward)\n",
+    "                self.episode_reward = 0\n",
+    "            else:\n",
+    "                self.state = FloatTensor(next_state[\"agent_0\"])\n",
+    "        values = compute_true_values(states, rewards, dones).unsqueeze(1)\n",
+    "        return states, actions, values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "a5bb4113-8511-437b-ae9d-1e9f45005073",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def compute_true_values(states, rewards, dones):\n",
+    "    true_values = []\n",
+    "    rewards = FloatTensor(rewards)\n",
+    "    dones = FloatTensor(dones)\n",
+    "    states = torch.stack(states)\n",
+    "\n",
+    "    if dones[-1] == True:\n",
+    "        next_value = rewards[-1]\n",
+    "    else:\n",
+    "        next_value = model.get_critic(states[-1].unsqueeze(0))\n",
+    "\n",
+    "    true_values.append(next_value)\n",
+    "    for i in reversed(range(0, len(rewards) -1)):\n",
+    "        if not dones[i]:\n",
+    "            next_value = rewards[i] + next_value * gamma\n",
+    "        else:\n",
+    "            next_value = rewards[i]\n",
+    "        true_values.append(next_value)\n",
+    "    true_values.reverse()\n",
+    "    return FloatTensor(true_values)\n",
+    "\n",
+    "def reflect(memory):\n",
+    "    states, actions, true_values = memory.pop_all()\n",
+    "    values, log_probs, entropy = model.evaluate_action(states, actions)\n",
+    "    advantages = true_values - values\n",
+    "    critic_loss = advantages.pow(2).mean()\n",
+    "    actor_loss = -(log_probs * advantages.detach()).mean()\n",
+    "    total_loss = (critic_coef * critic_loss) + actor_loss - (entropy_coef * entropy)\n",
+    "    optimizer.zero_grad()\n",
+    "    total_loss.backward()\n",
+    "    torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)\n",
+    "    optimizer.step()\n",
+    "    return values.mean().item()\n",
+    "\n",
+    "def plot(data, frame_idx):\n",
+    "    clear_output(True)\n",
+    "    plt.figure(figsize=(20, 5))\n",
+    "    if data['episode_rewards']:\n",
+    "        ax = plt.subplot(121)\n",
+    "        ax = plt.gca()\n",
+    "        average_score = np.mean(data['episode_rewards'][-100:])\n",
+    "        plt.title(f\"Frame: {frame_idx} - Average Store: {average_score}\")\n",
+    "        plt.grid()\n",
+    "        plt.plot(data['episode_rewards'])\n",
+    "    if data['values']:\n",
+    "        ax = plt.subplot(122)\n",
+    "        average_value = np.mean(data['values'][-1000:])\n",
+    "        plt.title(f\"Frame: {frame_idx} - Average Values: {average_value}\")\n",
+    "        plt.plot(data['values'])\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "3f0c10ca-c344-450d-ad78-bd418860ea5d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "env = simple_v3.parallel_env()\n",
+    "model = Model(env.observation_space(\"agent_0\").shape[0], env.action_space(\"agent_0\").n)\n",
+    "optimizer = torch.optim.RMSprop(model.parameters(), lr=learning_rate, eps=1e-5)\n",
+    "memory = Memory()\n",
+    "workers = []\n",
+    "for _ in range(no_of_workers):\n",
+    "    workers.append(Worker())\n",
+    "frame_idx = 0\n",
+    "data = {\n",
+    "    'episode_rewards': [],\n",
+    "    'values': []\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "1b3bae48-f47e-4b8b-be8a-271d7e6871c0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%debug\n",
+    "state = FloatTensor(env.reset()[0][\"agent_0\"])\n",
+    "episode_reward = 0\n",
+    "while frame_idx < max_frames:\n",
+    "    for worker in workers:\n",
+    "        states, actions, true_values = worker.get_batch()\n",
+    "        for i, _ in enumerate(states):\n",
+    "            memory.push(states[i], actions[i], true_values[i])\n",
+    "        frame_idx += batch_size\n",
+    "    value = reflect(memory)\n",
+    "    data['values'].append(value)\n",
+    "    if frame_idx % 1000 == 0:\n",
+    "        plot(data, frame_idx)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "c6db61c0-6828-4283-855d-0d734b36a1fa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "torch.save(model, \"MyModel.pt\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "9ef651cb-69d4-4c37-a92b-de5d4a9fe5a2",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'self' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mNameError\u001b[39m                                 Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[12]\u001b[39m\u001b[32m, line 3\u001b[39m\n\u001b[32m      1\u001b[39m env = simple_v3.parallel_env(render_mode=\u001b[33m\"\u001b[39m\u001b[33mhuman\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m      2\u001b[39m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[32m----> \u001b[39m\u001b[32m3\u001b[39m     \u001b[38;5;28mself\u001b[39m.state = FloatTensor(\u001b[38;5;28;43mself\u001b[39;49m.env.reset()[\u001b[32m0\u001b[39m][\u001b[33m\"\u001b[39m\u001b[33magent_0\u001b[39m\u001b[33m\"\u001b[39m])\n\u001b[32m      4\u001b[39m     \u001b[38;5;28;01mwhile\u001b[39;00m env.agents():\n\u001b[32m      5\u001b[39m         action = model.act(\u001b[38;5;28mself\u001b[39m.state.unsqueeze(\u001b[32m0\u001b[39m))\n",
+      "\u001b[31mNameError\u001b[39m: name 'self' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "env = simple_v3.parallel_env(render_mode=\"human\")\n",
+    "while True:\n",
+    "    state = FloatTensor(env.reset()[0][\"agent_0\"])\n",
+    "    while env.agents():\n",
+    "        action = model.act(state.unsqueeze(0))\n",
+    "        actiondict = {}\n",
+    "        actiondict[\"agent_0\"] = action\n",
+    "        next_state, reward, terminations, truncations, _ = env.step(actiondict)\n",
+    "        done = False if \"agent_0\" in terminations else True\n",
+    "\n",
+    "        if done:\n",
+    "            state = FloatTensor(env.reset()[0][\"agent_0\"])\n",
+    "        else:\n",
+    "            state = FloatTensor(next_state[\"agent_0\"])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "machine_learning",
+   "language": "python",
+   "name": "machine_learning"
+  },
+  "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.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/.ipynb_checkpoints/test-checkpoint.py b/.ipynb_checkpoints/test-checkpoint.py
new file mode 100644
index 0000000..8e5e7f1
--- /dev/null
+++ b/.ipynb_checkpoints/test-checkpoint.py
@@ -0,0 +1,156 @@
+import torch
+from pettingzoo.mpe import simple_reference_v3,simple_v3
+import numpy as np
+from IPython.display import clear_output
+from IPython.core.debugger import set_trace
+import matplotlib.pyplot as plt
+
+class Model(torch.nn.Module):
+    def __init__(self, observation_space, action_space):
+        super(Model, self).__init__()
+        self.features = torch.nn.Sequential(
+            torch.nn.Linear(observation_space, 32),
+            torch.nn.ReLU(),
+            torch.nn.Linear(32, 128),
+            torch.nn.ReLu()
+        )
+
+        self.critic = torch.nn.Sequential(
+            torch.nn.Linear(128, 256),
+            torch.nn.ReLU(),
+            torch.nn.Linear(256, 1)
+        )
+
+        self.actor = torch.nn.Sequential(
+            torch.nn.Linear(128, 256),
+            torch.nn.ReLU(),
+            torch.nn.Linear(256, action_space)
+        )
+    
+    def forward(self, x):
+        x = self.features(x)
+        value = self.critic(x)
+        actions = self.actor(x)
+        return value, actions
+
+    def get_critic(self, x):
+        x = self.features(x)
+        return self.critic(x)
+    
+    def evaluate_action(self, state, action):
+        value, actor_features = self.forward(state)
+        dist = torch.distributions.Categorical(actor_features)
+        log_probs = dist.log_prob(action).view(-1, 1)
+        entropy = dist.entropy().mean()
+
+        return value, log_rpobs, entropy
+    
+    def act(self, state):
+        value, actor_features = self.forward(state)
+        dist = torch.distributions.Categorical(actor_features)
+
+        chosen_action = dist.sample()
+        return chosen_action.item()
+
+class Memory(object):
+    def __init__(self):
+        self.states, self.actions, self.true_values = [], [], []
+    
+    def push(self, state, action, true_value):
+        self.states.append(state)
+        self.actions.append(action)
+        self.true_values.append(true_value)
+    
+    def pop_all(self):
+        states = torch.stack(self.states)
+        actions = LongTensor(self.actions)
+        true_values = FloatTensor(self.true_values).unsqueeze(1)
+
+        self.states, self.actions, self.true_values = [], [], []
+        return states, actions, true_values
+
+class Worker(object):
+    def __init__(self):
+        self.env = simple_v3.parallel_env()
+        self.episode_reward = 0
+        self.state = FloatTensor(self.env.reset()[0])
+
+    def get_batch(self):
+        states, actions, rewards, dones = [], [], [], []
+        for _ in range(batch_size):
+            action = model.act(torch.Tensor(self.state["agent_0"]).unsqueeze(0))
+            actions = []
+            actions["agent_0"] = action
+            next_state, rewards, terminations, truncations, _ = env.step(actions)
+            self.episode_reward += rewards["agent_0"]
+            states.append(torch.Tensor(self.state["agent_0"]))
+            actions.append(action)
+            rewards.append(reward["agent_0"])
+            done = terminations["agent_0"] or truncations["agent_0"]
+            dones.append(done)
+
+            if done:
+                self.state = FloatTensor(self.env.reset()[0])
+                data['episode_rewards'].append(self.episode_reward)
+                self.episode_reward = 0
+            else:
+                self.state = FloatTensor(next_state)
+        values = compute_true_values(states, rewards, dones).unsqueeze(1)
+        return states, actions, values
+
+
+
+def compute_true_values(states, rewards, dones):
+    true_values = []
+    rewards = FloatTensor(rewards)
+    dones = FloatTensor(dones)
+    states = torch.stack(states)
+
+    if dones[-1] == True:
+        next_value = rewards[-1]
+    else:
+        next_value = model.get_critic(states[-1].unsqueeze(0))
+
+    true_values.append(next_value)
+    for i in reversed(range(0, len(rewards) -1)):
+        if not dones[i]:
+            next_value = rewards[i] + next_value * gamma
+        else:
+            next_value = rewards[i]
+        true_values.append(next_value)
+    true_values.reverse()
+    return FloatTensor(true_values)
+
+def reflect(memory):
+    states, actions, true_values = memory.pop_all()
+    values, log_probs, entropy = model.evaluate_action(states, actions)
+    advantages = true_values - values
+    critic_loss = advantages.pow(2).mean()
+    actor_loss = -(log_probs * advantages.detach()).mean()
+    total_loss = (critic_coef * critic_loss) + actor_loss - (entropy_coef * entropy)
+    optimizer.zero_grad()
+    total_loss.backward()
+    tourch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)
+    optimizer.step()
+    return values.mean().item()
+
+def plot(data, frame_idx):
+    clear_output(True)
+    plt.figure(figsize=(20, 5))
+    if data['episode_rewards']:
+        ax = plt.subplot(121)
+        ax.plt.gca()
+        average_score = np.mean(data['episode_rewards'][-100:])
+        plt.title(f"Frame: {frame_idx} - Average Store: {average_score}")
+        plt.grid()
+        plt.plot(data['episode_rewards'])
+    if data['values']:
+        ax = plt.subplot(122)
+        average_value = np.mean(data['values'][-1000:0])
+        plt.title(f"Frame: {frame_idx} - Average Values: {average_value}")
+        plt.plot(data['values'])
+    plt.show()
+
+env = simple_v3.parallel_env()
+model = Model(env.observation_space("agent_0").shape[0], env.action_space("agent_0").n)
+optimizer = torch.optim.RMSprop(model.parameters(), lr=learning_rate, eps=1e-5)
diff --git a/Test.ipynb b/Test.ipynb
new file mode 100644
index 0000000..502a8e9
--- /dev/null
+++ b/Test.ipynb
@@ -0,0 +1,360 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "5ebc5698-7678-4730-8bdb-26d39cc3969d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/piwalker/code/machine_learning/simple_crypto/venv/lib/python3.13/site-packages/pygame/pkgdata.py:25: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n",
+      "  from pkg_resources import resource_stream, resource_exists\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from pettingzoo.mpe import simple_reference_v3,simple_v3\n",
+    "import numpy as np\n",
+    "from IPython.display import clear_output\n",
+    "from IPython.core.debugger import set_trace\n",
+    "import matplotlib.pyplot as plt\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "c1eaeab6-4b9e-4b5c-8db2-bd79b3887413",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "max_frames = 5000000\n",
+    "batch_size = 5\n",
+    "learning_rate = 7e-4\n",
+    "gamma = 0.99\n",
+    "entropy_coef = 0.01\n",
+    "critic_coef = 0.5\n",
+    "no_of_workers = 16"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "5da2c091-9ac7-4142-803c-4e8b2b4c586e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "FloatTensor = torch.FloatTensor\n",
+    "LongTensor = torch.LongTensor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "04f39958-d3f8-4484-a7fd-97f7da05cd4b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Model(torch.nn.Module):\n",
+    "    def __init__(self, observation_space, action_space):\n",
+    "        super(Model, self).__init__()\n",
+    "        self.features = torch.nn.Sequential(\n",
+    "            torch.nn.Linear(observation_space, 32),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(32, 128),\n",
+    "            torch.nn.ReLU()\n",
+    "        )\n",
+    "\n",
+    "        self.critic = torch.nn.Sequential(\n",
+    "            torch.nn.Linear(128, 256),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(256, 1)\n",
+    "        )\n",
+    "\n",
+    "        self.actor = torch.nn.Sequential(\n",
+    "            torch.nn.Linear(128, 256),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(256, action_space),\n",
+    "            torch.nn.Softmax(dim=-1)\n",
+    "        )\n",
+    "    \n",
+    "    def forward(self, x):\n",
+    "        x = self.features(x)\n",
+    "        value = self.critic(x)\n",
+    "        actions = self.actor(x)\n",
+    "        return value, actions\n",
+    "\n",
+    "    def get_critic(self, x):\n",
+    "        x = self.features(x)\n",
+    "        return self.critic(x)\n",
+    "    \n",
+    "    def evaluate_action(self, state, action):\n",
+    "        value, actor_features = self.forward(state)\n",
+    "        dist = torch.distributions.Categorical(actor_features)\n",
+    "        log_probs = dist.log_prob(action).view(-1, 1)\n",
+    "        entropy = dist.entropy().mean()\n",
+    "\n",
+    "        return value, log_probs, entropy\n",
+    "    \n",
+    "    def act(self, state):\n",
+    "        value, actor_features = self.forward(state)\n",
+    "        dist = torch.distributions.Categorical(actor_features)\n",
+    "\n",
+    "        chosen_action = dist.sample()\n",
+    "        return chosen_action.item()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "58dcf7c9-6405-4d83-9ea5-bdebdd614db8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Memory(object):\n",
+    "    def __init__(self):\n",
+    "        self.states, self.actions, self.true_values = [], [], []\n",
+    "    \n",
+    "    def push(self, state, action, true_value):\n",
+    "        self.states.append(state)\n",
+    "        self.actions.append(action)\n",
+    "        self.true_values.append(true_value)\n",
+    "    \n",
+    "    def pop_all(self):\n",
+    "        states = torch.stack(self.states)\n",
+    "        actions = LongTensor(self.actions)\n",
+    "        true_values = FloatTensor(self.true_values).unsqueeze(1)\n",
+    "\n",
+    "        self.states, self.actions, self.true_values = [], [], []\n",
+    "        return states, actions, true_values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "4edd19f6-193e-4183-9eab-498f176b32a2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Worker(object):\n",
+    "    def __init__(self):\n",
+    "        self.env = simple_v3.parallel_env()\n",
+    "        self.episode_reward = 0\n",
+    "        self.state = FloatTensor(self.env.reset()[0][\"agent_0\"])\n",
+    "\n",
+    "    def get_batch(self):\n",
+    "        states, actions, rewards, dones = [], [], [], []\n",
+    "        for _ in range(batch_size):\n",
+    "            action = model.act(self.state.unsqueeze(0))\n",
+    "            actiondict = {}\n",
+    "            actiondict[\"agent_0\"] = action\n",
+    "            next_state, reward, terminations, truncations, _ = self.env.step(actiondict)\n",
+    "            self.episode_reward += reward[\"agent_0\"]\n",
+    "            states.append(self.state)\n",
+    "            actions.append(action)\n",
+    "            rewards.append(reward[\"agent_0\"])\n",
+    "            done = False if \"agent_0\" in terminations else True\n",
+    "            dones.append(done)\n",
+    "\n",
+    "            if done:\n",
+    "                self.state = FloatTensor(self.env.reset()[0][\"agent_0\"])\n",
+    "                data['episode_rewards'].append(self.episode_reward)\n",
+    "                self.episode_reward = 0\n",
+    "            else:\n",
+    "                self.state = FloatTensor(next_state[\"agent_0\"])\n",
+    "        values = compute_true_values(states, rewards, dones).unsqueeze(1)\n",
+    "        return states, actions, values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "a5bb4113-8511-437b-ae9d-1e9f45005073",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def compute_true_values(states, rewards, dones):\n",
+    "    true_values = []\n",
+    "    rewards = FloatTensor(rewards)\n",
+    "    dones = FloatTensor(dones)\n",
+    "    states = torch.stack(states)\n",
+    "\n",
+    "    if dones[-1] == True:\n",
+    "        next_value = rewards[-1]\n",
+    "    else:\n",
+    "        next_value = model.get_critic(states[-1].unsqueeze(0))\n",
+    "\n",
+    "    true_values.append(next_value)\n",
+    "    for i in reversed(range(0, len(rewards) -1)):\n",
+    "        if not dones[i]:\n",
+    "            next_value = rewards[i] + next_value * gamma\n",
+    "        else:\n",
+    "            next_value = rewards[i]\n",
+    "        true_values.append(next_value)\n",
+    "    true_values.reverse()\n",
+    "    return FloatTensor(true_values)\n",
+    "\n",
+    "def reflect(memory):\n",
+    "    states, actions, true_values = memory.pop_all()\n",
+    "    values, log_probs, entropy = model.evaluate_action(states, actions)\n",
+    "    advantages = true_values - values\n",
+    "    critic_loss = advantages.pow(2).mean()\n",
+    "    actor_loss = -(log_probs * advantages.detach()).mean()\n",
+    "    total_loss = (critic_coef * critic_loss) + actor_loss - (entropy_coef * entropy)\n",
+    "    optimizer.zero_grad()\n",
+    "    total_loss.backward()\n",
+    "    torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)\n",
+    "    optimizer.step()\n",
+    "    return values.mean().item()\n",
+    "\n",
+    "def plot(data, frame_idx):\n",
+    "    clear_output(True)\n",
+    "    plt.figure(figsize=(20, 5))\n",
+    "    if data['episode_rewards']:\n",
+    "        ax = plt.subplot(121)\n",
+    "        ax = plt.gca()\n",
+    "        average_score = np.mean(data['episode_rewards'][-100:])\n",
+    "        plt.title(f\"Frame: {frame_idx} - Average Store: {average_score}\")\n",
+    "        plt.grid()\n",
+    "        plt.plot(data['episode_rewards'])\n",
+    "    if data['values']:\n",
+    "        ax = plt.subplot(122)\n",
+    "        average_value = np.mean(data['values'][-1000:])\n",
+    "        plt.title(f\"Frame: {frame_idx} - Average Values: {average_value}\")\n",
+    "        plt.plot(data['values'])\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "3f0c10ca-c344-450d-ad78-bd418860ea5d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "env = simple_v3.parallel_env()\n",
+    "model = Model(env.observation_space(\"agent_0\").shape[0], env.action_space(\"agent_0\").n)\n",
+    "optimizer = torch.optim.RMSprop(model.parameters(), lr=learning_rate, eps=1e-5)\n",
+    "memory = Memory()\n",
+    "workers = []\n",
+    "for _ in range(no_of_workers):\n",
+    "    workers.append(Worker())\n",
+    "frame_idx = 0\n",
+    "data = {\n",
+    "    'episode_rewards': [],\n",
+    "    'values': []\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "1b3bae48-f47e-4b8b-be8a-271d7e6871c0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%debug\n",
+    "state = FloatTensor(env.reset()[0][\"agent_0\"])\n",
+    "episode_reward = 0\n",
+    "while frame_idx < max_frames:\n",
+    "    for worker in workers:\n",
+    "        states, actions, true_values = worker.get_batch()\n",
+    "        for i, _ in enumerate(states):\n",
+    "            memory.push(states[i], actions[i], true_values[i])\n",
+    "        frame_idx += batch_size\n",
+    "    value = reflect(memory)\n",
+    "    data['values'].append(value)\n",
+    "    if frame_idx % 1000 == 0:\n",
+    "        plot(data, frame_idx)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "c6db61c0-6828-4283-855d-0d734b36a1fa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "torch.save(model, \"MyModel.pt\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "9ef651cb-69d4-4c37-a92b-de5d4a9fe5a2",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mKeyboardInterrupt\u001b[39m                         Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[15]\u001b[39m\u001b[32m, line 8\u001b[39m\n\u001b[32m      6\u001b[39m actiondict = {}\n\u001b[32m      7\u001b[39m actiondict[\u001b[33m\"\u001b[39m\u001b[33magent_0\u001b[39m\u001b[33m\"\u001b[39m] = action\n\u001b[32m----> \u001b[39m\u001b[32m8\u001b[39m next_state, reward, terminations, truncations, _ = \u001b[43menv\u001b[49m\u001b[43m.\u001b[49m\u001b[43mstep\u001b[49m\u001b[43m(\u001b[49m\u001b[43mactiondict\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m      9\u001b[39m done = \u001b[38;5;28;01mFalse\u001b[39;00m \u001b[38;5;28;01mif\u001b[39;00m \u001b[33m\"\u001b[39m\u001b[33magent_0\u001b[39m\u001b[33m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m terminations \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[32m     11\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m done:\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/code/machine_learning/simple_crypto/venv/lib/python3.13/site-packages/pettingzoo/utils/conversions.py:207\u001b[39m, in \u001b[36maec_to_parallel_wrapper.step\u001b[39m\u001b[34m(self, actions)\u001b[39m\n\u001b[32m    203\u001b[39m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mAssertionError\u001b[39;00m(\n\u001b[32m    204\u001b[39m             \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mexpected agent \u001b[39m\u001b[38;5;132;01m{\u001b[39;00magent\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m got agent \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m.aec_env.agent_selection\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m, Parallel environment wrapper expects agents to step in a cycle.\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m    205\u001b[39m         )\n\u001b[32m    206\u001b[39m obs, rew, termination, truncation, info = \u001b[38;5;28mself\u001b[39m.aec_env.last()\n\u001b[32m--> \u001b[39m\u001b[32m207\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43maec_env\u001b[49m\u001b[43m.\u001b[49m\u001b[43mstep\u001b[49m\u001b[43m(\u001b[49m\u001b[43mactions\u001b[49m\u001b[43m[\u001b[49m\u001b[43magent\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    208\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m agent \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m.aec_env.agents:\n\u001b[32m    209\u001b[39m     rewards[agent] += \u001b[38;5;28mself\u001b[39m.aec_env.rewards[agent]\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/code/machine_learning/simple_crypto/venv/lib/python3.13/site-packages/pettingzoo/utils/wrappers/order_enforcing.py:96\u001b[39m, in \u001b[36mOrderEnforcingWrapper.step\u001b[39m\u001b[34m(self, action)\u001b[39m\n\u001b[32m     94\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m     95\u001b[39m     \u001b[38;5;28mself\u001b[39m._has_updated = \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m96\u001b[39m     \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43mstep\u001b[49m\u001b[43m(\u001b[49m\u001b[43maction\u001b[49m\u001b[43m)\u001b[49m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/code/machine_learning/simple_crypto/venv/lib/python3.13/site-packages/pettingzoo/utils/wrappers/base.py:47\u001b[39m, in \u001b[36mBaseWrapper.step\u001b[39m\u001b[34m(self, action)\u001b[39m\n\u001b[32m     46\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mstep\u001b[39m(\u001b[38;5;28mself\u001b[39m, action: ActionType) -> \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m---> \u001b[39m\u001b[32m47\u001b[39m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43menv\u001b[49m\u001b[43m.\u001b[49m\u001b[43mstep\u001b[49m\u001b[43m(\u001b[49m\u001b[43maction\u001b[49m\u001b[43m)\u001b[49m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/code/machine_learning/simple_crypto/venv/lib/python3.13/site-packages/pettingzoo/utils/wrappers/assert_out_of_bounds.py:26\u001b[39m, in \u001b[36mAssertOutOfBoundsWrapper.step\u001b[39m\u001b[34m(self, action)\u001b[39m\n\u001b[32m     16\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mstep\u001b[39m(\u001b[38;5;28mself\u001b[39m, action: ActionType) -> \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m     17\u001b[39m     \u001b[38;5;28;01massert\u001b[39;00m (\n\u001b[32m     18\u001b[39m         action \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m     19\u001b[39m         \u001b[38;5;129;01mand\u001b[39;00m (\n\u001b[32m   (...)\u001b[39m\u001b[32m     24\u001b[39m         action\n\u001b[32m     25\u001b[39m     ), \u001b[33m\"\u001b[39m\u001b[33maction is not in action space\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m---> \u001b[39m\u001b[32m26\u001b[39m     \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43mstep\u001b[49m\u001b[43m(\u001b[49m\u001b[43maction\u001b[49m\u001b[43m)\u001b[49m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/code/machine_learning/simple_crypto/venv/lib/python3.13/site-packages/pettingzoo/utils/wrappers/base.py:47\u001b[39m, in \u001b[36mBaseWrapper.step\u001b[39m\u001b[34m(self, action)\u001b[39m\n\u001b[32m     46\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mstep\u001b[39m(\u001b[38;5;28mself\u001b[39m, action: ActionType) -> \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m---> \u001b[39m\u001b[32m47\u001b[39m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43menv\u001b[49m\u001b[43m.\u001b[49m\u001b[43mstep\u001b[49m\u001b[43m(\u001b[49m\u001b[43maction\u001b[49m\u001b[43m)\u001b[49m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/code/machine_learning/simple_crypto/venv/lib/python3.13/site-packages/pettingzoo/mpe/_mpe_utils/simple_env.py:264\u001b[39m, in \u001b[36mSimpleEnv.step\u001b[39m\u001b[34m(self, action)\u001b[39m\n\u001b[32m    261\u001b[39m \u001b[38;5;28mself\u001b[39m._accumulate_rewards()\n\u001b[32m    263\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.render_mode == \u001b[33m\"\u001b[39m\u001b[33mhuman\u001b[39m\u001b[33m\"\u001b[39m:\n\u001b[32m--> \u001b[39m\u001b[32m264\u001b[39m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mrender\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/code/machine_learning/simple_crypto/venv/lib/python3.13/site-packages/pettingzoo/mpe/_mpe_utils/simple_env.py:287\u001b[39m, in \u001b[36mSimpleEnv.render\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m    285\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.render_mode == \u001b[33m\"\u001b[39m\u001b[33mhuman\u001b[39m\u001b[33m\"\u001b[39m:\n\u001b[32m    286\u001b[39m     pygame.display.flip()\n\u001b[32m--> \u001b[39m\u001b[32m287\u001b[39m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mclock\u001b[49m\u001b[43m.\u001b[49m\u001b[43mtick\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mmetadata\u001b[49m\u001b[43m[\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mrender_fps\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    288\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m\n",
+      "\u001b[31mKeyboardInterrupt\u001b[39m: "
+     ]
+    }
+   ],
+   "source": [
+    "env = simple_v3.parallel_env(render_mode=\"human\")\n",
+    "while True:\n",
+    "    state = FloatTensor(env.reset()[0][\"agent_0\"])\n",
+    "    while env.agents:\n",
+    "        action = model.act(state.unsqueeze(0))\n",
+    "        actiondict = {}\n",
+    "        actiondict[\"agent_0\"] = action\n",
+    "        next_state, reward, terminations, truncations, _ = env.step(actiondict)\n",
+    "        done = False if \"agent_0\" in terminations else True\n",
+    "\n",
+    "        if done:\n",
+    "            state = FloatTensor(env.reset()[0][\"agent_0\"])\n",
+    "        else:\n",
+    "            state = FloatTensor(next_state[\"agent_0\"])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "machine_learning",
+   "language": "python",
+   "name": "machine_learning"
+  },
+  "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.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/main.py b/main.py
index ff5ea2f..cbc6e77 100644
--- a/main.py
+++ b/main.py
@@ -9,7 +9,7 @@ import matplotlib.pyplot as plt
 from tqdm import tqdm
 
 import gymnasium as gym
-from pettingzoo.mpe import simple_reference_v3
+from pettingzoo.mpe import simple_reference_v3,simple_v3
 import pettingzoo
 
 class A2C(nn.Module):
@@ -53,8 +53,8 @@ class A2C(nn.Module):
         self.critic_optim = optim.Adam(self.critic.parameters(), lr=critic_lr)
         self.actor_optim = optim.Adam(self.actor.parameters(), lr=actor_lr)
 
-        self.critic_scheduler = optim.lr_scheduler.StepLR(self.critic_optim, step_size=100, gamma=1)
-        self.actor_scheduler = optim.lr_scheduler.StepLR(self.actor_optim, step_size=100, gamma=1)
+        #self.critic_scheduler = optim.lr_scheduler.StepLR(self.critic_optim, step_size=100, gamma=0.9)
+        #self.actor_scheduler = optim.lr_scheduler.StepLR(self.actor_optim, step_size=100, gamma=0.9)
 
     def forward(self, x: np.array) -> tuple[torch.tensor, torch.tensor]:
         x = torch.Tensor(x).to(self.device)
@@ -89,32 +89,34 @@ class A2C(nn.Module):
         ent_coef: float,
         ) -> tuple[torch.tensor, torch.tensor]:
 
-        T = len(rewards)
-        advantages = torch.zeros(T, device=self.device)
+        #T = len(rewards)
+        #rewards = (rewards - np.mean(rewards)) / (np.std(rewards) + 1e-5)
+        #advantages = torch.zeros(T, device=self.device)
 
         # compute the advantages using GAE
-        gae = 0.0
-        for t in reversed(range(T - 1)):
-            td_error = (
-                rewards[t] + gamma * masks[t] * value_preds[t+1] - value_preds[t]
-            )
-            gae = td_error + gamma * 0.95 * masks[t] * gae
-            advantages[t] = gae
+        #gae = 0.0
+        #for t in reversed(range(T - 1)):
+        #    td_error = (
+        #        rewards[t] + gamma * masks[t] * value_preds[t+1] - value_preds[t]
+        #    )
+        #    gae = td_error + gamma * 0.95 * masks[t] * gae
+        #    advantages[t] = gae
+        
+        #advantages = (advantages - advantages.mean()) / advantages.std()
         
         # calculate the loss of the minibatch for actor and critic
-        critic_loss = advantages.pow(2).mean()
+        #critic_loss = advantages.pow(2).mean()
 
         #give a bonus for higher entropy to encourage exploration
-        actor_loss = (
-            -(advantages.detach() * action_log_probs).mean() - ent_coef * torch.Tensor(entropy).mean()
-        )
+        #actor_loss = (
+        #    -(advantages.detach() * action_log_probs).mean() - ent_coef * torch.Tensor(entropy).mean()
+        #)
 
 
         #advantages = torch.zeros(len(rewards), device=self.device)
         #compute advantages 
         #mask - 0 if end of episode
         #gamma - coeffecient for value prediction
-        #rewards = (rewards - np.mean(rewards)) / (np.std(rewards) + 1e-5)
         #for t in range(len(rewards) - 1):
             #advantages[t] = (rewards[t] + masks[t] * gamma * (value_preds[t+1] - value_preds[t]))
             #print(advantages[t])
@@ -122,25 +124,25 @@ class A2C(nn.Module):
             #(rewards[t] + masks[t] * gamma * (value_preds[t+1] - value_preds[t]))
         #rewards = np.array(rewards)
         #rewards = (rewards - np.mean(rewards)) / (np.std(rewards) + 1e-5)
-        #returns = []
-        #R = 0
-        #for r, mask in zip(reversed(rewards), reversed(masks)):
-        #    R = r + gamma * R * mask
-        #    returns.insert(0, R)
+        returns = []
+        R = 0
+        for r, mask in zip(reversed(rewards), reversed(masks)):
+            R = r + gamma * R * mask
+            returns.insert(0, R)
         
-        #returns = torch.FloatTensor(returns)
-        #values = torch.stack(value_preds).squeeze(1)
+        returns = torch.FloatTensor(returns)
+        values = torch.stack(value_preds).squeeze(1)
 
-        #advantage = returns - values
+        advantage = returns - values
 
 
         #calculate critic loss - MSE
-        #critic_loss = advantages.pow(2).mean()
+        critic_loss = advantage.pow(2).mean()
         #critic_loss = advantages.pow(2).mean()
         #calculate actor loss - give bonus for entropy to encourage exploration
         #actor_loss = -(advantages.detach() * action_log_probs).mean() - ent_coef * entropy.mean()
         #entropy = -torch.stack(entropy).sum(dim=-1).mean()
-        #actor_loss = (-action_log_probs * advantages.detach()).mean() - ent_coef * torch.Tensor(entropy).mean()
+        actor_loss = (-action_log_probs * advantage.detach()).mean() - ent_coef * torch.Tensor(entropy).mean()
         #print(action_log_probs)
         #print(actor_loss)
         return (critic_loss, actor_loss)
@@ -150,19 +152,18 @@ class A2C(nn.Module):
         critic_loss.backward()
         torch.nn.utils.clip_grad_norm_(self.critic.parameters(), 0.5)
         self.critic_optim.step()
-        self.critic_scheduler.step()
+        #self.critic_scheduler.step()
 
         self.actor_optim.zero_grad()
         actor_loss.backward()
         torch.nn.utils.clip_grad_norm_(self.actor.parameters(), 0.5)
         self.actor_optim.step()
-        self.actor_scheduler.step()
+        #self.actor_scheduler.step()
 
     def set_eval(self):
         self.critic.eval()
         self.actor.eval()
 
-
 fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(15,5))
 fig.suptitle(
     f"training plots for the Simple Reference environment"
@@ -247,7 +248,8 @@ def train(n_episodes, gamma, ent_coef, actor_lr, critic_lr):
     agent1_rewards = []
     agent0_entropy = []
     agent1_entropy = []
-    env = simple_reference_v3.parallel_env(max_cycles = 50, render_mode="rgb_array")
+    #env = simple_reference_v3.parallel_env(max_cycles = 50, render_mode="rgb_array")
+    env = simple_v3.parallel_env(max_cycles = 50, render_mode="rgb_array")
     #obs_space
     #action_space
 
@@ -265,7 +267,7 @@ def train(n_episodes, gamma, ent_coef, actor_lr, critic_lr):
     #alice = A2C(n_features = env.observation_space("alice_0").shape[0], n_actions = env.action_space("alice_0").n, device = device, critic_lr = critic_lr, actor_lr = actor_lr)
 
     agent0 = A2C(n_features = env.observation_space("agent_0").shape[0], n_actions = env.action_space("agent_0").n, device = device, critic_lr = critic_lr, actor_lr = actor_lr)
-    agent1 = A2C(n_features = env.observation_space("agent_1").shape[0], n_actions = env.action_space("agent_1").n, device = device, critic_lr = critic_lr, actor_lr = actor_lr)
+    #agent1 = A2C(n_features = env.observation_space("agent_1").shape[0], n_actions = env.action_space("agent_1").n, device = device, critic_lr = critic_lr, actor_lr = actor_lr)
     #print(env.action_space("agent_0").n)
     #print(env.observation_space("agent_0"))
 
@@ -293,9 +295,9 @@ def train(n_episodes, gamma, ent_coef, actor_lr, critic_lr):
             #actions["bob_0"] = bob_action.item()
             #actions["alice_0"] = alice_action.item()
             agent_0_action, agent_0_log_probs, agent_0_state_val, agent_0_ent = agent0.select_action(torch.FloatTensor(observations["agent_0"]).unsqueeze(0))
-            agent_1_action, agent_1_log_probs, agent_1_state_val, agent_1_ent = agent1.select_action(torch.FloatTensor(observations["agent_1"]).unsqueeze(0))
+            #agent_1_action, agent_1_log_probs, agent_1_state_val, agent_1_ent = agent1.select_action(torch.FloatTensor(observations["agent_1"]).unsqueeze(0))
             actions["agent_0"] = agent_0_action
-            actions["agent_1"] = agent_1_action
+            #actions["agent_1"] = agent_1_action
             observations, rewards, terminations, truncations, infos = env.step(actions)
             #print(rewards)
             agent_0_rewards.append(rewards["agent_0"])
@@ -304,11 +306,11 @@ def train(n_episodes, gamma, ent_coef, actor_lr, critic_lr):
             agent_0_ents.append(agent_0_ent.item())
             agent_0_mask.append( 1 if env.agents else 0)
 
-            agent_1_rewards.append(rewards["agent_1"])
-            agent_1_probs.append(agent_1_log_probs)
-            agent_1_pred.append(agent_1_state_val)
-            agent_1_ents.append(agent_1_ent.item())
-            agent_1_mask.append( 1 if env.agents else 0)
+            #agent_1_rewards.append(rewards["agent_1"])
+            #agent_1_probs.append(agent_1_log_probs)
+            #agent_1_pred.append(agent_1_state_val)
+            #agent_1_ents.append(agent_1_ent.item())
+            #agent_1_mask.append( 1 if env.agents else 0)
             #eve_closs, eve_aloss = eve.get_losses([rewards["eve_0"]], eve_log_probs, eve_state_val, eve_ent, [1], gamma, ent_coef)
             #print("Eve: Critic Loss: " + str(eve_closs.item()) + " Actor Loss: " + str(eve_aloss.item()))
             #eve.update_params(eve_closs, eve_aloss)
@@ -318,17 +320,17 @@ def train(n_episodes, gamma, ent_coef, actor_lr, critic_lr):
         agent0_actor_loss.append(agent_0_aloss.item())
         #print("Agent 0 loss: Critic: " + str(agent_0_closs.item()) + ", Actor: " + str(agent_0_aloss.item()))
         agent0.update_params(agent_0_closs, agent_0_aloss)
-        agent_1_closs, agent_1_aloss = agent1.get_losses(agent_1_rewards, torch.stack(agent_1_probs), agent_1_pred, agent_1_ents, agent_1_mask, gamma, ent_coef)
-        agent1_critic_loss.append(agent_1_closs.item())
-        agent1_actor_loss.append(agent_1_aloss.item())
+        #agent_1_closs, agent_1_aloss = agent1.get_losses(agent_1_rewards, torch.stack(agent_1_probs), agent_1_pred, agent_1_ents, agent_1_mask, gamma, ent_coef)
+        #agent1_critic_loss.append(agent_1_closs.item())
+        #agent1_actor_loss.append(agent_1_aloss.item())
         #print("Agent 1 loss: Critic: " + str(agent_1_closs.item()) + ", Actor: " + str(agent_1_aloss.item()))
-        agent1.update_params(agent_1_closs, agent_1_aloss)
+        #agent1.update_params(agent_1_closs, agent_1_aloss)
 
         agent0_rewards.append(np.array(agent_0_rewards).sum())
-        agent1_rewards.append(np.array(agent_1_rewards).sum())
+        #agent1_rewards.append(np.array(agent_1_rewards).sum())
         #print(np.array(agent_0_ents).sum())
-        agent0_entropy.append(np.array(agent_0_ents).sum())
-        agent1_entropy.append(np.array(agent_1_ents).sum())
+        agent0_entropy.append(np.array(agent_0_ents).mean())
+        #agent1_entropy.append(np.array(agent_1_ents).sum())
         
         
         
@@ -337,13 +339,42 @@ def train(n_episodes, gamma, ent_coef, actor_lr, critic_lr):
             plt.savefig('plots(gamma=' + str(gamma) + ',ent=' + str(ent_coef) + ',alr=' + str(actor_lr) + ',clr=' + str(critic_lr) + ').png')
     drawPlots()
     plt.savefig('plots(gamma=' + str(gamma) + ',ent=' + str(ent_coef) + ',alr=' + str(actor_lr) + ',clr=' + str(critic_lr) + ').png')
+
+    actor0_weights_path = "weights/actor0_weights.h5"
+    critic0_weights_path = "weights/critic0_weights.h5"
+    actor1_weights_path = "weights/actor1_weights.h5"
+    critic1_weights_path = "weights/critic1_weights.h5"
+
+    if not os.path.exists("weights"):
+        os.mkdir("weights")
+
+    torch.save(agent0.actor.state_dict(), actor0_weights_path)
+    torch.save(agent0.critic.state_dict(), critic0_weights_path)
+    #torch.save(agent1.actor.state_dict(), actor1_weights_path)
+    #torch.save(agent1.critic.state_dict(), critic1_weights_path)
+
+    agent0.set_eval()
+    #agent1.set_eval()
+    #env = simple_reference_v3.parallel_env(render_mode="human")
+    env = simple_v3.parallel_env(render_mode="human")
+    while True:
+        observations, infos = env.reset()
+        while env.agents:
+            plt.pause(0.001)
+            actions = {}
+            agent_0_action, agent_0_log_probs, agent_0_state_val, agent_0_ent = agent0.select_action(torch.FloatTensor(observations["agent_0"]).unsqueeze(0))
+            #agent_1_action, agent_1_log_probs, agent_1_state_val, agent_1_ent = agent1.select_action(torch.FloatTensor(observations["agent_1"]).unsqueeze(0))
+            actions["agent_0"] = agent_0_action
+            #actions["agent_1"] = agent_1_action
+            observations, rewards, terminations, truncations, infos = env.step(actions)
+
     env.close()
 
 
 
 #environment hyperparams
 n_episodes = 1000
-train(10000, 0.999, 0.01, 0.0001, 0.0005)
+train(10000, 0.9, 0.03, 0.001, 0.005)
 best = 1
 for gamma in np.arange(0.999, 0.99, -0.1):
     for ent_coef in np.arange(0, 0.1, 0.01):