diff --git a/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/gs-gym b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/gs-gym
new file mode 160000
index 0000000..23a1bed
--- /dev/null
+++ b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/gs-gym	
@@ -0,0 +1 @@
+Subproject commit 23a1bed2cd27a361b1da92f570aab024b2683108
diff --git a/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/main.ipynb b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/main.ipynb
new file mode 100644
index 0000000..1f638aa
--- /dev/null
+++ b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/main.ipynb	
@@ -0,0 +1,32 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "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.11.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/my_keras-test.ipynb b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/my_keras-test.ipynb
new file mode 100644
index 0000000..8ac440f
--- /dev/null
+++ b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/my_keras-test.ipynb	
@@ -0,0 +1,320 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "0bbb53e7-84e7-4d65-baab-05421b7e7bc3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2.10.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "import keras\n",
+    "print(keras.__version__)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9d23266a-38fb-430f-9502-85526a86a5d1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from keras import layers\n",
+    "inputs = layers.Input(shape=(1,))\n",
+    "layer1 = layers.Dense(512, activation=\"relu\")(inputs)\n",
+    "outputs = layers.Dense(3, activation=\"linear\")(layer1)\n",
+    "nn_model = keras.Model(inputs=inputs, outputs=outputs)\n",
+    "nn_model.summary()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "397f97d8-18de-4855-ad94-89e461f85b6e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "output = nn_model(0.5) #throws erros"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bded47b5-69fe-40cf-9cb4-78a360ee4244",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "input = keras.backend.constant([[0.5]])\n",
+    "output = nn_model(input)\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d10e5212-c663-49c2-bb0f-34956c23070a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "inputs = np.arange(0, 1.1, 0.1)\n",
+    "input = keras.backend.constant([[0.5]])\n",
+    "input2 = keras.backend.constant([inputs])\n",
+    "output = nn_model(input)\n",
+    "print(input)\n",
+    "print(input2)\n",
+    "print(output)\n",
+    "print(inputs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0111c2c1-6c00-4859-8715-e74fcc3883bd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import gym\n",
+    "e = gym.make('MountainCarContinuous-v0')\n",
+    "e.reset()\n",
+    "e.render()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2dcfd9d1-43b6-48f0-9435-9ef75158152c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import gym\n",
+    "e = gym.make('MountainCarContinuous-v0')\n",
+    "s1 = e.reset()\n",
+    "print(s1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1d4a9391-4af2-47c8-b310-06c5b3016f59",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "e.action_space.sample()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "77781c43-bb1e-41ce-b878-2245edf9a094",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from keras import layers\n",
+    "inputs = layers.Input(shape=(2, ))\n",
+    "layer1 = layers.Dense(512, activation=\"relu\")(inputs)\n",
+    "outputs = layers.Dense(1, activation=\"linear\")(layer1)\n",
+    "nn_model = keras.Model(inputs=inputs, outputs=outputs)\n",
+    "s = e.reset()\n",
+    "input = keras.backend.constant([s])\n",
+    "a = nn_model(input)\n",
+    "s,r,d,i = e.step(a)\n",
+    "print(s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e94051cc-7498-4c85-b296-a79669d4bc64",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Control the agent with the network\n",
+    "from keras import layers\n",
+    "inputs = layers.Input(shape=(2, ))\n",
+    "layer1 = layers.Dense(512, activation=\"relu\")(inputs)\n",
+    "outputs = layers.Dense(1, activation=\"linear\")(layer1)\n",
+    "nn_model = keras.Model(inputs=inputs, outputs=outputs)\n",
+    "for item in range(10):\n",
+    "    s = e.reset()\n",
+    "    input = keras.backend.constant([s])\n",
+    "    a = nn_model(input)\n",
+    "    s,r,d,i = e.step(a)\n",
+    "    e.render()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0cba086b-4a65-4ee0-92d3-4ee752bf2161",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s = e.reset()\n",
+    "input = keras.backend.constant([s]) # s is an array\n",
+    "a = nn_model(input)\n",
+    "s,r,d,i = e.step(a)\n",
+    "print(s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "fb686ff6-aa76-4446-b81f-1b26db98022d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "pygame 2.1.2 (SDL 2.0.18, Python 3.10.8)\n",
+      "Hello from the pygame community. https://www.pygame.org/contribute.html\n",
+      "Discrete(4)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Breakwall enviroment again\n",
+    "import keras\n",
+    "import gym\n",
+    "# We get a discrete (4) action space\n",
+    "env_name = \"gym_gs:BreakwallNoFrameskip-v1\"\n",
+    "e = gym.make(env_name)\n",
+    "s = e.reset()\n",
+    "print(e.action_space)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "585e3e61-4745-45f1-beec-d25bf6a78c11",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2\n",
+      "Observation/ state shape: (600, 780, 3)\n",
+      "0\n",
+      "Observation/ state shape: (600, 780, 3)\n",
+      "3\n",
+      "Observation/ state shape: (600, 780, 3)\n",
+      "0\n",
+      "Observation/ state shape: (600, 780, 3)\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i in range(4):\n",
+    "    print(e.action_space.sample())\n",
+    "    print(\"Observation/ state shape:\", s.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "2a45d350-cf9b-459d-a1f7-1470809e14cf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tf.Tensor([[0. 0. 0. 0.]], shape=(1, 4), dtype=float32)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# We'll update the imput layer\n",
+    "from keras import layers\n",
+    "inputs = layers.Input(shape=(600,780,3,))\n",
+    "layer1 = layers.Flatten()(inputs) # We flatten the the 3D input layer\n",
+    "layer2 = layers.Dense(512, activation=\"relu\")(layer1)\n",
+    "outputs = layers.Dense(4, activation=\"linear\")(layer2)\n",
+    "nn_model = keras.Model(inputs=inputs, outputs=outputs)\n",
+    "state = e.reset()\n",
+    "state_tensor = keras.backend.constant(state)\n",
+    "state_tensor = keras.backend.expand_dims(state_tensor, 0)\n",
+    "action_values = nn_model(state_tensor)\n",
+    "print(action_values)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c27e9935-2a2c-4dd4-82e0-43b86d3e0de5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "action = keras.backend.argmax(action_values[0]).numpy()\n",
+    "action = tf.argmax(action_probs[0]).numpy() # if renamed\n",
+    "print(keras.backend.argmax([0.1,0.5,0.01,0.2]).numpy())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "053e95dd-48af-4c18-949b-12d5a13e1a3e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tf.Tensor([[-135.33052    -34.96535     -2.6175923  104.20433  ]], shape=(1, 4), dtype=float32) 3\n",
+      "tf.Tensor([[-133.47585    -40.308247    -9.9967165  100.298096 ]], shape=(1, 4), dtype=float32) 3\n",
+      "tf.Tensor([[-133.52586   -34.83712    -9.089392  106.48525 ]], shape=(1, 4), dtype=float32) 3\n",
+      "tf.Tensor([[-142.65623   -37.653713  -12.290092  100.456726]], shape=(1, 4), dtype=float32) 3\n",
+      "tf.Tensor([[-139.46967   -29.941523  -15.024807  102.14433 ]], shape=(1, 4), dtype=float32) 3\n",
+      "tf.Tensor([[-137.86325   -28.1824    -18.672073  102.72069 ]], shape=(1, 4), dtype=float32) 3\n",
+      "tf.Tensor([[-134.41286   -29.641228  -12.233908  105.396324]], shape=(1, 4), dtype=float32) 3\n",
+      "tf.Tensor([[-139.85345    -27.45109    -11.1273575   93.42384  ]], shape=(1, 4), dtype=float32) 3\n",
+      "tf.Tensor([[-134.20053   -29.01193   -11.014997   94.585106]], shape=(1, 4), dtype=float32) 3\n",
+      "tf.Tensor([[-136.16206   -31.467659   -6.581274   96.69547 ]], shape=(1, 4), dtype=float32) 3\n"
+     ]
+    }
+   ],
+   "source": [
+    "state = e.reset()\n",
+    "state,r,d,i = e.step(1)\n",
+    "for i in range(10):\n",
+    "    state_tensor = keras.backend.constant(state)\n",
+    "    state_tensor = keras.backend.expand_dims(state_tensor, 0)\n",
+    "    action_values = nn_model(state_tensor)\n",
+    "    action = keras.backend.argmax(action_values[0]).numpy()\n",
+    "    print(action_values, action)\n",
+    "    state,r,d,i = e.step(1)\n",
+    "    e.render()"
+   ]
+  }
+ ],
+ "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.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/my_mountain-car.ipynb b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/my_mountain-car.ipynb
new file mode 100644
index 0000000..3685bcb
--- /dev/null
+++ b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/my_mountain-car.ipynb	
@@ -0,0 +1,108 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ec755efa-2052-422b-b49d-fe46a343d568",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import gym\n",
+    "for n in gym.envs.registry.all():\n",
+    "    print(n)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "01167b07-819c-40c8-a5c8-5463c43c8925",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import gym\n",
+    "import matplotlib.pyplot as plt\n",
+    "#e = gym.make('gym_gs:BreakwallNoFrameskip-v1')\n",
+    "env_name = \"MountainCarContinuous-v0\"\n",
+    "e = gym.make(env_name)\n",
+    "e.reset()\n",
+    "e.render()\n",
+    "# img = e.render('rgb_array')\n",
+    "# plt.imshow(e.render(mode='rgb_array'))b\n",
+    "# img = e.render('rgb_array')\n",
+    "# plt.imshow(e.render(mode='rgb_array'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "9328b324-7f9a-4178-94c4-d1f8cec07542",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([-0.51512,  0.     ])"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "e.reset()\n",
+    "e.step(e.action_space.sample())\n",
+    "e.render()\n",
+    "e.reset()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "547ccc71-8e9e-4d56-8cea-bfeddd002845",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "77a096e6-3fa9-48be-8bf0-06367ac9f9aa",
+   "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.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/my_mujoco.ipynb b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/my_mujoco.ipynb
new file mode 100644
index 0000000..b21fcfb
--- /dev/null
+++ b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/my_mujoco.ipynb	
@@ -0,0 +1,75 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9d9f64ee-0186-4475-ba63-b5a569662227",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import gym\n",
+    "for n in gym.envs.registry.all():\n",
+    "    print(n)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "ace720b1-7121-4a81-8369-f5cfc40cbe36",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "Exception",
+     "evalue": "Please add mujoco library to your PATH:\nset PATH=C:\\Users\\gofor\\.mujoco\\mujoco210\\bin;%PATH%",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mException\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn [1], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mmujoco_py\u001b[39;00m\n\u001b[0;32m      2\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mos\u001b[39;00m\n\u001b[0;32m      3\u001b[0m mj_path \u001b[38;5;241m=\u001b[39m mujoco_py\u001b[38;5;241m.\u001b[39mutils\u001b[38;5;241m.\u001b[39mdiscover_mujoco()\n",
+      "File \u001b[1;32m~\\venv310\\lib\\site-packages\\mujoco_py\\__init__.py:2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m#!/usr/bin/env python\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mmujoco_py\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mbuilder\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m cymj, ignore_mujoco_warnings, functions, MujocoException\n\u001b[0;32m      3\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mmujoco_py\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mgenerated\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m const\n\u001b[0;32m      4\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mmujoco_py\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mmjrenderpool\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m MjRenderPool\n",
+      "File \u001b[1;32m~\\venv310\\lib\\site-packages\\mujoco_py\\builder.py:504\u001b[0m\n\u001b[0;32m    500\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39mlib\u001b[38;5;241m.\u001b[39m__fun\n\u001b[0;32m    503\u001b[0m mujoco_path \u001b[38;5;241m=\u001b[39m discover_mujoco()\n\u001b[1;32m--> 504\u001b[0m cymj \u001b[38;5;241m=\u001b[39m \u001b[43mload_cython_ext\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmujoco_path\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    507\u001b[0m \u001b[38;5;66;03m# Trick to expose all mj* functions from mujoco in mujoco_py.*\u001b[39;00m\n\u001b[0;32m    508\u001b[0m \u001b[38;5;28;01mclass\u001b[39;00m \u001b[38;5;21;01mdict2\u001b[39;00m(\u001b[38;5;28mobject\u001b[39m):\n",
+      "File \u001b[1;32m~\\venv310\\lib\\site-packages\\mujoco_py\\builder.py:83\u001b[0m, in \u001b[0;36mload_cython_ext\u001b[1;34m(mujoco_path)\u001b[0m\n\u001b[0;32m     81\u001b[0m     var \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPATH\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m     82\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m var \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m os\u001b[38;5;241m.\u001b[39menviron \u001b[38;5;129;01mor\u001b[39;00m lib_path \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m os\u001b[38;5;241m.\u001b[39menviron[var]\u001b[38;5;241m.\u001b[39msplit(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m;\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m---> 83\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPlease add mujoco library to your PATH:\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m     84\u001b[0m                         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mset \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m=\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m;\u001b[39m\u001b[38;5;132;01m%%\u001b[39;00m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;132;01m%%\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m (var, lib_path, var))\n\u001b[0;32m     85\u001b[0m     Builder \u001b[38;5;241m=\u001b[39m WindowsExtensionBuilder\n\u001b[0;32m     86\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
+      "\u001b[1;31mException\u001b[0m: Please add mujoco library to your PATH:\nset PATH=C:\\Users\\gofor\\.mujoco\\mujoco210\\bin;%PATH%"
+     ]
+    }
+   ],
+   "source": [
+    "import mujoco_py\n",
+    "import os\n",
+    "mj_path = mujoco_py.utils.discover_mujoco()\n",
+    "xml_path = os.path.join(mj_path, 'model', 'humanoid.xml')\n",
+    "model = mujoco_py.load_model_from_path(xml_path)\n",
+    "sim = mujoco_py.MjSim(model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aa696af6-b6d2-4916-be15-93052eb43b3c",
+   "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.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/my_run_pre_trained.ipynb b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/my_run_pre_trained.ipynb
new file mode 100644
index 0000000..d327761
--- /dev/null
+++ b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/my_run_pre_trained.ipynb	
@@ -0,0 +1,668 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Run a pre-trained model\n",
+    "\n",
+    "This notebook loads a pre-trained model and uses it to play games. \n",
+    "Note that it does not render the image of the game, it just prints out the episodic score. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "os.getcwd()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "pygame 2.1.2 (SDL 2.0.18, Python 3.10.8)\n",
+      "Hello from the pygame community. https://www.pygame.org/contribute.html\n"
+     ]
+    }
+   ],
+   "source": [
+    "# sanity check: can we create breakwall?\n",
+    "import gym\n",
+    "import matplotlib.pyplot as plt\n",
+    "#e = gym.make('gym_gs:BreakwallNoFrameskip-v1')\n",
+    "env_name = \"gym_gs:BreakwallNoFrameskip-v1\"\n",
+    "e = gym.make(env_name)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x232117ece50>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "e.reset()\n",
+    "img = e.render('rgb_array')\n",
+    "plt.imshow(e.render(mode='rgb_array'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([[[0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         ...,\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0]],\n",
+       " \n",
+       "        [[0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         ...,\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0]],\n",
+       " \n",
+       "        [[0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         ...,\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0]],\n",
+       " \n",
+       "        ...,\n",
+       " \n",
+       "        [[0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         ...,\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0]],\n",
+       " \n",
+       "        [[0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         ...,\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0]],\n",
+       " \n",
+       "        [[0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         ...,\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0]]], dtype=uint8),\n",
+       " 0,\n",
+       " False,\n",
+       " {})"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "e.step(1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x2321335b7c0>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "img = e.render('rgb_array')\n",
+    "plt.imshow(e.render(mode='rgb_array'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(600, 780, 3)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "array([[0, 0, 0, ..., 0, 0, 0],\n",
+       "       [0, 0, 0, ..., 0, 0, 0],\n",
+       "       [0, 0, 0, ..., 0, 0, 0],\n",
+       "       ...,\n",
+       "       [0, 0, 0, ..., 0, 0, 0],\n",
+       "       [0, 0, 0, ..., 0, 0, 0],\n",
+       "       [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "s,a,d,i = e.step(1)\n",
+    "print(s.shape)\n",
+    "s[:,:,0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import gym\n",
+    "import matplotlib.pyplot as plt\n",
+    "env_name = \"gym_gs:BreakwallNoFrameskip-v1\"\n",
+    "e = gym.make(env_name)\n",
+    "e.reset()\n",
+    "s,a,d,i = e.step(1)\n",
+    "plt.imshow(s[:,:,0]) # show only the red channel\n",
+    "# if not running in a notebook environment\n",
+    "# run this to show the single channel\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x23218180280>"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import gym\n",
+    "import matplotlib.pyplot as plt\n",
+    "env_name = \"gym_gs:BreakwallNoFrameskip-v1\"\n",
+    "e = gym.make(env_name)\n",
+    "e.reset()\n",
+    "s,a,d,i = e.step(1)\n",
+    "plt.imshow(s[:,:,1]) # show only the red channel\n",
+    "# if not running in a notebook environment\n",
+    "# run this to show the single channel\n",
+    "#plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x23212bf9ae0>"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import gym\n",
+    "import matplotlib.pyplot as plt\n",
+    "env_name = \"gym_gs:BreakwallNoFrameskip-v1\"\n",
+    "e = gym.make(env_name)\n",
+    "e.reset()\n",
+    "s,a,d,i = e.step(1)\n",
+    "plt.imshow(s[:,:,2]) # show only the red channel\n",
+    "# if not running in a notebook environment\n",
+    "# run this to show the single channel\n",
+    "#plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Discrete(4)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(e.action_space)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Taking action  0\n",
+      "Taking action  1\n",
+      "Taking action  2\n",
+      "Taking action  3\n"
+     ]
+    }
+   ],
+   "source": [
+    "for action in range(4):\n",
+    "    print(\"Taking action \", action)\n",
+    "    e.step(action)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([[[0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         ...,\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0]],\n",
+       " \n",
+       "        [[0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         ...,\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0]],\n",
+       " \n",
+       "        [[0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         ...,\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0]],\n",
+       " \n",
+       "        ...,\n",
+       " \n",
+       "        [[0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         ...,\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0]],\n",
+       " \n",
+       "        [[0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         ...,\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0]],\n",
+       " \n",
+       "        [[0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         ...,\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0],\n",
+       "         [0, 0, 0]]], dtype=uint8),\n",
+       " 0,\n",
+       " False,\n",
+       " {})"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "action = e.action_space.sample()\n",
+    "e.step(action)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x23244a906d0>"
+      ]
+     },
+     "execution_count": 41,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "e.reset()\n",
+    "action = e.action_space.sample();\n",
+    "for i in range(100):\n",
+    "    if i % 10 == 0:\n",
+    "        action = e.action_space.sample()\n",
+    "    e.step(action)\n",
+    "img = e.render('rgb_array')\n",
+    "plt.imshow(e.render(mode='rgb_array'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Collecting git+https://github.com/openai/baselines.git"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  Running command git clone --filter=blob:none --quiet https://github.com/openai/baselines.git 'C:\\Users\\gofor\\AppData\\Local\\Temp\\pip-req-build-d82n0u3f'\n",
+      "\n",
+      "[notice] A new release of pip available: 22.2.2 -> 22.3.1\n",
+      "[notice] To update, run: python.exe -m pip install --upgrade pip\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "  Cloning https://github.com/openai/baselines.git to c:\\users\\gofor\\appdata\\local\\temp\\pip-req-build-d82n0u3f\n",
+      "  Resolved https://github.com/openai/baselines.git to commit ea25b9e8b234e6ee1bca43083f8f3cf974143998\n",
+      "  Preparing metadata (setup.py): started\n",
+      "  Preparing metadata (setup.py): finished with status 'done'\n",
+      "Requirement already satisfied: gym<0.16.0,>=0.15.4 in c:\\users\\gofor\\venv310\\lib\\site-packages (from baselines==0.1.6) (0.15.7)\n",
+      "Requirement already satisfied: scipy in c:\\users\\gofor\\venv310\\lib\\site-packages (from baselines==0.1.6) (1.9.3)\n",
+      "Requirement already satisfied: tqdm in c:\\users\\gofor\\venv310\\lib\\site-packages (from baselines==0.1.6) (4.64.1)\n",
+      "Requirement already satisfied: joblib in c:\\users\\gofor\\venv310\\lib\\site-packages (from baselines==0.1.6) (1.2.0)\n",
+      "Requirement already satisfied: cloudpickle in c:\\users\\gofor\\venv310\\lib\\site-packages (from baselines==0.1.6) (1.2.2)\n",
+      "Requirement already satisfied: click in c:\\users\\gofor\\venv310\\lib\\site-packages (from baselines==0.1.6) (8.1.3)\n",
+      "Requirement already satisfied: opencv-python in c:\\users\\gofor\\venv310\\lib\\site-packages (from baselines==0.1.6) (4.6.0.66)\n",
+      "Requirement already satisfied: pyglet<=1.5.0,>=1.4.0 in c:\\users\\gofor\\venv310\\lib\\site-packages (from gym<0.16.0,>=0.15.4->baselines==0.1.6) (1.5.0)\n",
+      "Requirement already satisfied: numpy>=1.10.4 in c:\\users\\gofor\\venv310\\lib\\site-packages (from gym<0.16.0,>=0.15.4->baselines==0.1.6) (1.23.4)\n",
+      "Requirement already satisfied: six in c:\\users\\gofor\\venv310\\lib\\site-packages (from gym<0.16.0,>=0.15.4->baselines==0.1.6) (1.16.0)\n",
+      "Requirement already satisfied: colorama in c:\\users\\gofor\\venv310\\lib\\site-packages (from click->baselines==0.1.6) (0.4.6)\n",
+      "Requirement already satisfied: future in c:\\users\\gofor\\venv310\\lib\\site-packages (from pyglet<=1.5.0,>=1.4.0->gym<0.16.0,>=0.15.4->baselines==0.1.6) (0.18.2)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# install baselines and other stuff\n",
+    "!pip install git+https://github.com/openai/baselines.git"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\gofor\\venv310\\lib\\site-packages\\gym\\logger.py:30: UserWarning: \u001b[33mWARN: Box bound precision lowered by casting to float32\u001b[0m\n",
+      "  warnings.warn(colorize('%s: %s'%('WARN', msg % args), 'yellow'))\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loaded gym\n",
+      "Model weights look loadable ./pre-trained/mac_hard_breakwall/gym_gs_BreakwallNoFrameskip-v1_20211018-114642_5424.data-00000-of-00001\n",
+      "Model loaded weights - starting sim\n",
+      "Game over at frame 72 rew 0.0\n",
+      "Game over at frame 387 rew 13.0\n",
+      "Game over at frame 705 rew 26.0\n",
+      "Game over at frame 980 rew 28.0\n",
+      "Sim ended : rew is  28.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "## full check - can we use the full opencv/ openai version \n",
+    "## of the gym?\n",
+    "\n",
+    "# Script to test a pre-trained model\n",
+    "# Written by Matthew Yee-King\n",
+    "# MIT license \n",
+    "# https://mit-license.org/\n",
+    "\n",
+    "import sys\n",
+    "import os\n",
+    "from baselines.common.atari_wrappers import make_atari, wrap_deepmind\n",
+    "import numpy as np\n",
+    "import tensorflow as tf\n",
+    "from tensorflow import keras\n",
+    "from tensorflow.keras import layers\n",
+    "import datetime\n",
+    "import random\n",
+    "import time \n",
+    "\n",
+    "# env_name = \"gym_gs:BreakwallNoFrameskip-v1\" \n",
+    "env_name = \"BreakwallNoFrameskip-v1\" \n",
+    "# for notebook users - make sure you have uploaded your pre-trained\n",
+    "# models... then adjust this to reflect the file path\n",
+    "# model_file = \"./pre-trained/mac_hard_breakwall/gym_gs:BreakwallNoFrameskip-v1_20211018-114642_5424\"\n",
+    "model_file = \"./pre-trained/mac_hard_breakwall/gym_gs_BreakwallNoFrameskip-v1_20211018-114642_5424\"\n",
+    "\n",
+    "def create_q_model(num_actions):\n",
+    "    # Network defined by the Deepmind paper\n",
+    "    inputs = layers.Input(shape=(84, 84, 4,))\n",
+    "    # Convolutions on the frames on the screen\n",
+    "    layer1 = layers.Conv2D(32, 8, strides=4, activation=\"relu\")(inputs)    \n",
+    "    layer2 = layers.Conv2D(64, 4, strides=2, activation=\"relu\")(layer1)\n",
+    "    layer3 = layers.Conv2D(64, 3, strides=1, activation=\"relu\")(layer2)\n",
+    "    layer4 = layers.Flatten()(layer3)\n",
+    "    layer5 = layers.Dense(512, activation=\"relu\")(layer4)    \n",
+    "    action = layers.Dense(num_actions, activation=\"linear\")(layer5)    \n",
+    "    return keras.Model(inputs=inputs, outputs=action)\n",
+    "\n",
+    "def create_env(env_name, seed=42):\n",
+    "    try:\n",
+    "        # Use the Baseline Atari environment because of Deepmind helper functions\n",
+    "        env = make_atari(env_name)\n",
+    "        # Warp the frames, grey scale, stake four frame and scale to smaller ratio\n",
+    "        env = wrap_deepmind(env, frame_stack=True, scale=True)\n",
+    "        print(\"Loaded gym\")\n",
+    "        env.seed(seed)\n",
+    "        return env\n",
+    "    except:\n",
+    "        print(\"Failed to make gym env\", env_name)\n",
+    "        return None\n",
+    "\n",
+    "def run_sim(env, model, frame_count):\n",
+    "    state = np.array(env.reset())\n",
+    "    total_reward = 0\n",
+    "    for i in range(frame_count):\n",
+    "        # in the notebook version we cannot really \n",
+    "        # render in realtime, so you just have\n",
+    "        # to check the score :( \n",
+    "        #env.render('human')\n",
+    "        state_tensor = keras.backend.constant(state)\n",
+    "        state_tensor = keras.backend.expand_dims(state_tensor, 0)\n",
+    "        action_values = model(state_tensor, training=False)\n",
+    "        # Take best action\n",
+    "        action = keras.backend.argmax(action_values[0]).numpy()\n",
+    "        state, reward, done, _ = env.step(action)\n",
+    "        state =  np.array(state)\n",
+    "        total_reward += reward\n",
+    "        if done:\n",
+    "            print(\"Game over at frame\", i, \"rew\", total_reward)\n",
+    "            env.reset()\n",
+    "            #break\n",
+    "        #time.sleep(0.1)\n",
+    "    print(\"Sim ended : rew is \", total_reward)\n",
+    "\n",
+    "def main(env_name, model_file,frame_count=1000,  seed=42):\n",
+    "    env = create_env(env_name=env_name)\n",
+    "    assert env is not None, \"Failed to make env \" + env_name\n",
+    "    model = create_q_model(num_actions=env.action_space.n)\n",
+    "    model_testfile = model_file + \".data-00000-of-00001\"\n",
+    "    assert os.path.exists(model_testfile), \"Failed to load model: \" + model_testfile\n",
+    "    print(\"Model weights look loadable\", model_testfile)\n",
+    "    model.load_weights(model_file)\n",
+    "    print(\"Model loaded weights - starting sim\")\n",
+    "    run_sim(env, model, frame_count)\n",
+    "        \n",
+    "main(env_name, model_file, frame_count=1000)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "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.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/pre-trained/aero_atari_breakout/BreakoutNoFrameskip-v4_20211027-205921_20065.data-00000-of-00001 b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/pre-trained/aero_atari_breakout/BreakoutNoFrameskip-v4_20211027-205921_20065.data-00000-of-00001
new file mode 100644
index 0000000..f0471db
Binary files /dev/null and b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/pre-trained/aero_atari_breakout/BreakoutNoFrameskip-v4_20211027-205921_20065.data-00000-of-00001 differ
diff --git a/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/pre-trained/aero_atari_breakout/BreakoutNoFrameskip-v4_20211027-205921_20065.index b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/pre-trained/aero_atari_breakout/BreakoutNoFrameskip-v4_20211027-205921_20065.index
new file mode 100644
index 0000000..1b2f959
Binary files /dev/null and b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/pre-trained/aero_atari_breakout/BreakoutNoFrameskip-v4_20211027-205921_20065.index differ
diff --git a/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/pre-trained/mac_hard_breakwall/gym_gs_BreakwallNoFrameskip-v1_20211018-114642_5424.data-00000-of-00001 b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/pre-trained/mac_hard_breakwall/gym_gs_BreakwallNoFrameskip-v1_20211018-114642_5424.data-00000-of-00001
new file mode 100644
index 0000000..4f4de58
Binary files /dev/null and b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/pre-trained/mac_hard_breakwall/gym_gs_BreakwallNoFrameskip-v1_20211018-114642_5424.data-00000-of-00001 differ
diff --git a/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/pre-trained/mac_hard_breakwall/gym_gs_BreakwallNoFrameskip-v1_20211018-114642_5424.index b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/pre-trained/mac_hard_breakwall/gym_gs_BreakwallNoFrameskip-v1_20211018-114642_5424.index
new file mode 100644
index 0000000..50ab063
Binary files /dev/null and b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/pre-trained/mac_hard_breakwall/gym_gs_BreakwallNoFrameskip-v1_20211018-114642_5424.index differ
diff --git a/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/run_pre_trained.ipynb b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/run_pre_trained.ipynb
new file mode 100644
index 0000000..5650785
--- /dev/null
+++ b/CM3020 Artificial Intelligence/Week 3/3.8 Lab Files/run_pre_trained.ipynb	
@@ -0,0 +1,189 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Run a pre-trained model\n",
+    "\n",
+    "This notebook loads a pre-trained model and uses it to play games. \n",
+    "Note that it does not render the image of the game, it just prints out the episodic score. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ModuleNotFoundError",
+     "evalue": "No module named 'gym'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn [3], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# sanity check: can we create breakwall?\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mgym\u001b[39;00m\n\u001b[0;32m      3\u001b[0m e \u001b[38;5;241m=\u001b[39m gym\u001b[38;5;241m.\u001b[39mmake(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mgym_gs:BreakwallNoFrameskip-v1\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
+      "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'gym'"
+     ]
+    }
+   ],
+   "source": [
+    "# sanity check: can we create breakwall?\n",
+    "import gym\n",
+    "e = gym.make('gym_gs:BreakwallNoFrameskip-v1')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# install baselines and other stuff\n",
+    "!pip install git+https://github.com/openai/baselines.git"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## full check - can we use the full opencv/ openai version \n",
+    "## of the gym?\n",
+    "\n",
+    "# Script to test a pre-trained model\n",
+    "# Written by Matthew Yee-King\n",
+    "# MIT license \n",
+    "# https://mit-license.org/\n",
+    "\n",
+    "import sys\n",
+    "import os\n",
+    "from baselines.common.atari_wrappers import make_atari, wrap_deepmind\n",
+    "import numpy as np\n",
+    "import tensorflow as tf\n",
+    "from tensorflow import keras\n",
+    "from tensorflow.keras import layers\n",
+    "import datetime\n",
+    "import random\n",
+    "import time \n",
+    "\n",
+    "env_name = \"gym_gs:BreakwallNoFrameskip-v1\" \n",
+    "# for notebook users - make sure you have uploaded your pre-trained\n",
+    "# models... then adjust this to reflect the file path\n",
+    "model_file = \"./pre-trained/mac_hard_breakwall/gym_gs:BreakwallNoFrameskip-v1_20211018-114642_5424\"\n",
+    "\n",
+    "def create_q_model(num_actions):\n",
+    "    # Network defined by the Deepmind paper\n",
+    "    inputs = layers.Input(shape=(84, 84, 4,))\n",
+    "    # Convolutions on the frames on the screen\n",
+    "    layer1 = layers.Conv2D(32, 8, strides=4, activation=\"relu\")(inputs)    \n",
+    "    layer2 = layers.Conv2D(64, 4, strides=2, activation=\"relu\")(layer1)\n",
+    "    layer3 = layers.Conv2D(64, 3, strides=1, activation=\"relu\")(layer2)\n",
+    "    layer4 = layers.Flatten()(layer3)\n",
+    "    layer5 = layers.Dense(512, activation=\"relu\")(layer4)    \n",
+    "    action = layers.Dense(num_actions, activation=\"linear\")(layer5)    \n",
+    "    return keras.Model(inputs=inputs, outputs=action)\n",
+    "\n",
+    "def create_env(env_name, seed=42):\n",
+    "    try:\n",
+    "        # Use the Baseline Atari environment because of Deepmind helper functions\n",
+    "        env = make_atari(env_name)\n",
+    "        # Warp the frames, grey scale, stake four frame and scale to smaller ratio\n",
+    "        env = wrap_deepmind(env, frame_stack=True, scale=True)\n",
+    "        print(\"Loaded gym\")\n",
+    "        env.seed(seed)\n",
+    "        return env\n",
+    "    except:\n",
+    "        print(\"Failed to make gym env\", env_name)\n",
+    "        return None\n",
+    "\n",
+    "def run_sim(env, model, frame_count):\n",
+    "    state = np.array(env.reset())\n",
+    "    total_reward = 0\n",
+    "    for i in range(frame_count):\n",
+    "        # in the notebook version we cannot really \n",
+    "        # render in realtime, so you just have\n",
+    "        # to check the score :( \n",
+    "        #env.render('human')\n",
+    "        state_tensor = keras.backend.constant(state)\n",
+    "        state_tensor = keras.backend.expand_dims(state_tensor, 0)\n",
+    "        action_values = model(state_tensor, training=False)\n",
+    "        # Take best action\n",
+    "        action = keras.backend.argmax(action_values[0]).numpy()\n",
+    "        state, reward, done, _ = env.step(action)\n",
+    "        state =  np.array(state)\n",
+    "        total_reward += reward\n",
+    "        if done:\n",
+    "            print(\"Game over at frame\", i, \"rew\", total_reward)\n",
+    "            env.reset()\n",
+    "            #break\n",
+    "        #time.sleep(0.1)\n",
+    "    print(\"Sim ended : rew is \", total_reward)\n",
+    "\n",
+    "def main(env_name, model_file,frame_count=1000,  seed=42):\n",
+    "    env = create_env(env_name=env_name)\n",
+    "    assert env is not None, \"Failed to make env \" + env_name\n",
+    "    model = create_q_model(num_actions=env.action_space.n)\n",
+    "    model_testfile = model_file + \".data-00000-of-00001\"\n",
+    "    assert os.path.exists(model_testfile), \"Failed to load model: \" + model_testfile\n",
+    "    print(\"Model weights look loadable\", model_testfile)\n",
+    "    model.load_weights(model_file)\n",
+    "    print(\"Model loaded weights - starting sim\")\n",
+    "    run_sim(env, model, frame_count)\n",
+    "        \n",
+    "main(env_name, model_file, frame_count=1000)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "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.11.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/CM3020 Artificial Intelligence/Week 3/Week 3 Notes.md b/CM3020 Artificial Intelligence/Week 3/Week 3 Notes.md
new file mode 100644
index 0000000..0b82247
--- /dev/null
+++ b/CM3020 Artificial Intelligence/Week 3/Week 3 Notes.md	
@@ -0,0 +1,49 @@
+# What is a gym?
+It's a way of providing standarized environments (API) for reinforcement learnign algorithms to operate in.
+
+Allows the developer to focus on the agent instead of the simulation.
+
+Includes versioned, standard set of enviroments enabling easy comparison.
+
+---
+There are various gym-like systems such as:
+* Arcade Learning Enviroment (2013)
+* Vizdoom (2016)
+* OpenAI gym (2016)
+
+# Open AI gym
+Aims to combine benchmarks collections in a convenient and accessible software package.
+
+# Keras
+A Neural network is a set of processing units which are interconnected, they are fed with values and also output values.
+
+Keras is a high level neural network API sitting atop tensorflow.
+
+The DQN we'll look at uses Keras.
+
+# Layers
+Neural networks are made of layers of which there are different types with different nodes in them which process signals in different ways.
+
+Keras provides many different types of layers
+https://keras.io/api/layers
+
+Convolution layers are great for image processing.
+
+Recurrent layers for sequential data.
+
+Attention layers for sequential data (better).
+
+DQN uses some common layers plus some convolutional layers.
+
+The nodes are fed data, the nodes create signals with value which are sent to other nodes. The results will be back propagated to the network again for processing.
+
+# Convolution layers
+Convolution is a filtering technique often used for images but also other signals. This is done by adding together scaled values of the original pixel and its surrounding pixels.
+
+Example of convolution filters are edge detection and blur filter.
+
+We can visualize what convolutional layers are doing to image data as it passes through the neural network.
+
+https://github.com/gabrielpierobon/cnnshapes/
+
+