diff --git a/.gitignore b/.gitignore
index 82f9275..dd02fbe 100644
--- a/.gitignore
+++ b/.gitignore
@@ -160,3 +160,6 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
+
+/wandb
+/data
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index c1fba16..054a1eb 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -17,3 +17,23 @@ repos:
       - id: end-of-file-fixer
       - id: mixed-line-ending
       - id: trailing-whitespace
+  # Black formatter
+  - repo: https://github.com/psf/black
+    rev: 24.4.0
+    hooks:
+      - id: black
+        args: ["--line-length=120"]
+
+  # Codespell - Fix common misspellings in text files.
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.2.6
+    hooks:
+      - id: codespell
+        args: ['--write-changes']
+
+  # Pyupgrade - automatically upgrade syntax for newer versions of the language.
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v3.15.2
+    hooks:
+      - id: pyupgrade
+        args: [--py310-plus]
diff --git a/Ex1.ipynb b/Ex1.ipynb
new file mode 100644
index 0000000..008799c
--- /dev/null
+++ b/Ex1.ipynb
@@ -0,0 +1,284 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from torch import nn\n",
+    "from torch.utils.data import DataLoader\n",
+    "from torchvision import datasets\n",
+    "from torchvision.transforms import ToTensor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "training_data = datasets.FashionMNIST(\n",
+    "    root=\"data\",\n",
+    "    train=True,\n",
+    "    download=True,\n",
+    "    transform=ToTensor(),\n",
+    ")\n",
+    "\n",
+    "test_data = datasets.FashionMNIST(\n",
+    "    root=\"data\",\n",
+    "    train=False,\n",
+    "    download=True,\n",
+    "    transform=ToTensor(),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Shape of X [N, C, H, W]: torch.Size([64, 1, 28, 28])\n",
+      "Shape of y: torch.Size([64]) torch.int64\n"
+     ]
+    }
+   ],
+   "source": [
+    "batch_size = 64\n",
+    "\n",
+    "train_dataloader = DataLoader(training_data, batch_size=batch_size)\n",
+    "test_dataloader = DataLoader(test_data, batch_size=batch_size)\n",
+    "\n",
+    "for X, y in test_dataloader:\n",
+    "    print(f\"Shape of X [N, C, H, W]: {X.shape}\")\n",
+    "    print(f\"Shape of y: {y.shape} {y.dtype}\")\n",
+    "    break"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Using cuda device\n",
+      "NeuralNetwork(\n",
+      "  (flatten): Flatten(start_dim=1, end_dim=-1)\n",
+      "  (linear_relu_stack): Sequential(\n",
+      "    (0): Linear(in_features=784, out_features=512, bias=True)\n",
+      "    (1): ReLU()\n",
+      "    (2): Linear(in_features=512, out_features=512, bias=True)\n",
+      "    (3): ReLU()\n",
+      "    (4): Linear(in_features=512, out_features=10, bias=True)\n",
+      "  )\n",
+      ")\n"
+     ]
+    }
+   ],
+   "source": [
+    "device = \"cuda\" if torch.cuda.is_available() else \"mps\" if torch.backends.mps.is_available() else \"cpu\"\n",
+    "print(f\"Using {device} device\")\n",
+    "\n",
+    "\n",
+    "class NeuralNetwork(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super().__init__()\n",
+    "        self.flatten = nn.Flatten()\n",
+    "        self.linear_relu_stack = nn.Sequential(\n",
+    "            nn.Linear(28 * 28, 512), nn.ReLU(), nn.Linear(512, 512), nn.ReLU(), nn.Linear(512, 10)\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.flatten(x)\n",
+    "        logits = self.linear_relu_stack(x)\n",
+    "        return logits\n",
+    "\n",
+    "\n",
+    "model = NeuralNetwork().to(device)\n",
+    "print(model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loss_fn = nn.CrossEntropyLoss()\n",
+    "optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def train(dataloader, model, loss_fn, optimizer):\n",
+    "    size = len(dataloader.dataset)\n",
+    "    model.train()\n",
+    "    for batch, (X, y) in enumerate(dataloader):\n",
+    "        X, y = X.to(device), y.to(device)\n",
+    "\n",
+    "        pred = model(X)\n",
+    "        loss = loss_fn(pred, y)\n",
+    "\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "        if batch % 100 == 0:\n",
+    "            loss, current = loss.item(), (batch + 1) * len(X)\n",
+    "            print(f\"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def test(dataloader, model, loss_fn):\n",
+    "    size = len(dataloader.dataset)\n",
+    "    num_batches = len(dataloader)\n",
+    "    model.eval()\n",
+    "    test_loss, correct = 0, 0\n",
+    "    with torch.no_grad():\n",
+    "        for X, y in dataloader:\n",
+    "            X, y = X.to(device), y.to(device)\n",
+    "            pred = model(X)\n",
+    "            test_loss += loss_fn(pred, y).item()\n",
+    "            correct += (pred.argmax(1) == y).type(torch.float).sum().item()\n",
+    "    test_loss /= num_batches\n",
+    "    correct /= size\n",
+    "    print(f\"Test Error: \\n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \\n\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1\n",
+      "-------------------------------\n",
+      "loss: 2.301345  [   64/60000]\n",
+      "loss: 2.289013  [ 6464/60000]\n",
+      "loss: 2.267571  [12864/60000]\n",
+      "loss: 2.253652  [19264/60000]\n",
+      "loss: 2.245495  [25664/60000]\n",
+      "loss: 2.214388  [32064/60000]\n",
+      "loss: 2.218577  [38464/60000]\n",
+      "loss: 2.192012  [44864/60000]\n",
+      "loss: 2.185515  [51264/60000]\n",
+      "loss: 2.154312  [57664/60000]\n",
+      "Test Error: \n",
+      " Accuracy: 46.3%, Avg loss: 2.144304 \n",
+      "\n",
+      "Epoch 2\n",
+      "-------------------------------\n",
+      "loss: 2.153029  [   64/60000]\n",
+      "loss: 2.143812  [ 6464/60000]\n",
+      "loss: 2.087860  [12864/60000]\n",
+      "loss: 2.103519  [19264/60000]\n",
+      "loss: 2.048817  [25664/60000]\n",
+      "loss: 1.996760  [32064/60000]\n",
+      "loss: 2.015409  [38464/60000]\n",
+      "loss: 1.948691  [44864/60000]\n",
+      "loss: 1.953080  [51264/60000]\n",
+      "loss: 1.880756  [57664/60000]\n",
+      "Test Error: \n",
+      " Accuracy: 60.8%, Avg loss: 1.873655 \n",
+      "\n",
+      "Epoch 3\n",
+      "-------------------------------\n",
+      "loss: 1.901290  [   64/60000]\n",
+      "loss: 1.874183  [ 6464/60000]\n",
+      "loss: 1.759593  [12864/60000]\n",
+      "loss: 1.804479  [19264/60000]\n",
+      "loss: 1.688624  [25664/60000]\n",
+      "loss: 1.641422  [32064/60000]\n",
+      "loss: 1.656471  [38464/60000]\n",
+      "loss: 1.567693  [44864/60000]\n",
+      "loss: 1.594154  [51264/60000]\n",
+      "loss: 1.483651  [57664/60000]\n",
+      "Test Error: \n",
+      " Accuracy: 63.9%, Avg loss: 1.499217 \n",
+      "\n",
+      "Epoch 4\n",
+      "-------------------------------\n",
+      "loss: 1.559186  [   64/60000]\n",
+      "loss: 1.532048  [ 6464/60000]\n",
+      "loss: 1.379261  [12864/60000]\n",
+      "loss: 1.455680  [19264/60000]\n",
+      "loss: 1.335025  [25664/60000]\n",
+      "loss: 1.325481  [32064/60000]\n",
+      "loss: 1.334234  [38464/60000]\n",
+      "loss: 1.269634  [44864/60000]\n",
+      "loss: 1.307040  [51264/60000]\n",
+      "loss: 1.203263  [57664/60000]\n",
+      "Test Error: \n",
+      " Accuracy: 64.5%, Avg loss: 1.229295 \n",
+      "\n",
+      "Epoch 5\n",
+      "-------------------------------\n",
+      "loss: 1.298207  [   64/60000]\n",
+      "loss: 1.292620  [ 6464/60000]\n",
+      "loss: 1.121837  [12864/60000]\n",
+      "loss: 1.233628  [19264/60000]\n",
+      "loss: 1.112199  [25664/60000]\n",
+      "loss: 1.126678  [32064/60000]\n",
+      "loss: 1.144357  [38464/60000]\n",
+      "loss: 1.091252  [44864/60000]\n",
+      "loss: 1.132425  [51264/60000]\n",
+      "loss: 1.049065  [57664/60000]\n",
+      "Test Error: \n",
+      " Accuracy: 65.3%, Avg loss: 1.068460 \n",
+      "\n",
+      "Done!\n"
+     ]
+    }
+   ],
+   "source": [
+    "epochs = 5\n",
+    "for t in range(epochs):\n",
+    "    print(f\"Epoch {t+1}\\n-------------------------------\")\n",
+    "    train(train_dataloader, model, loss_fn, optimizer)\n",
+    "    test(test_dataloader, model, loss_fn)\n",
+    "print(\"Done!\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ex2.ipynb b/Ex2.ipynb
new file mode 100644
index 0000000..087eed3
--- /dev/null
+++ b/Ex2.ipynb
@@ -0,0 +1,237 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from torchvision import datasets\n",
+    "from torchvision import transforms\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Transforms images to a PyTorch Tensor\n",
+    "tensor_transform = transforms.ToTensor()\n",
+    "\n",
+    "# Download the MNIST Dataset\n",
+    "dataset = datasets.FashionMNIST(root=\"./data\", download=True, transform=tensor_transform)\n",
+    "\n",
+    "# DataLoader is used to load the dataset\n",
+    "# for training\n",
+    "loader = torch.utils.data.DataLoader(dataset=dataset, batch_size=32, shuffle=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Creating a PyTorch class\n",
+    "# 28*28 ==> 9 ==> 28*28\n",
+    "class AE(torch.nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super().__init__()\n",
+    "\n",
+    "        # Building an linear encoder with Linear\n",
+    "        # layer followed by Relu activation function\n",
+    "        # 784 ==> 9\n",
+    "        self.encoder = torch.nn.Sequential(\n",
+    "            torch.nn.Linear(28 * 28, 128),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(128, 64),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(64, 36),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(36, 18),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(18, 9),\n",
+    "        )\n",
+    "\n",
+    "        # Building an linear decoder with Linear\n",
+    "        # layer followed by Relu activation function\n",
+    "        # The Sigmoid activation function\n",
+    "        # outputs the value between 0 and 1\n",
+    "        # 9 ==> 784\n",
+    "        self.decoder = torch.nn.Sequential(\n",
+    "            torch.nn.Linear(9, 18),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(18, 36),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(36, 64),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(64, 128),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(128, 28 * 28),\n",
+    "            torch.nn.Sigmoid(),\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        encoded = self.encoder(x)\n",
+    "        decoded = self.decoder(encoded)\n",
+    "        return decoded"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Model Initialization\n",
+    "model = AE()\n",
+    "\n",
+    "# Validation using MSE Loss function\n",
+    "loss_function = torch.nn.MSELoss()\n",
+    "\n",
+    "# Using an Adam Optimizer with lr = 0.1\n",
+    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-1, weight_decay=1e-8)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "epochs = 20\n",
+    "outputs = []\n",
+    "losses = []\n",
+    "for epoch in range(epochs):\n",
+    "    for image, _ in loader:\n",
+    "\n",
+    "        # Reshaping the image to (-1, 784)\n",
+    "        image = image.reshape(-1, 28 * 28)\n",
+    "\n",
+    "        # Output of Autoencoder\n",
+    "        reconstructed = model(image)\n",
+    "\n",
+    "        # Calculating the loss function\n",
+    "        loss = loss_function(reconstructed, image)\n",
+    "\n",
+    "        # The gradients are set to zero,\n",
+    "        # the gradient is computed and stored.\n",
+    "        # .step() performs parameter update\n",
+    "        optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "\n",
+    "        # Storing the losses in a list for plotting\n",
+    "        losses.append(loss)\n",
+    "    outputs.append((epochs, image, reconstructed))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.style.use(\"fivethirtyeight\")\n",
+    "plt.xlabel(\"Iterations\")\n",
+    "plt.ylabel(\"Loss\")\n",
+    "\n",
+    "losses_tensor = torch.tensor(losses)\n",
+    "\n",
+    "plt.plot(losses_tensor[-100:].detach().numpy())\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Images:\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reconstructed:\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "print(\"Images:\")\n",
+    "for i, item in enumerate(image):\n",
+    "    item = item.reshape(-1, 28, 28)\n",
+    "    plt.imshow(item[0].detach().numpy(), \"gray\")\n",
+    "plt.axis(\"off\")\n",
+    "plt.show()\n",
+    "\n",
+    "print(\"Reconstructed:\")\n",
+    "for i, item in enumerate(reconstructed):\n",
+    "    item = item.reshape(-1, 28, 28)\n",
+    "    plt.imshow(item[0].detach().numpy(), \"gray\")\n",
+    "plt.axis(\"off\")\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/README.md b/README.md
index 97b4080..729f8e2 100644
--- a/README.md
+++ b/README.md
@@ -253,4 +253,4 @@ study.best_params  # E.g. {'x': 2.002108042}
 ---
 ## Sources:
 
-- [github.com/leggedrobotics/plr-exercise](https://github.com/leggedrobotics/plr-exercise) by @JonasFrey96
\ No newline at end of file
+- [github.com/leggedrobotics/plr-exercise](https://github.com/leggedrobotics/plr-exercise) by @JonasFrey96
diff --git a/Screenshot from 2024-11-04 21-52-36.png b/Screenshot from 2024-11-04 21-52-36.png
new file mode 100644
index 0000000..19b0e9f
Binary files /dev/null and b/Screenshot from 2024-11-04 21-52-36.png differ
diff --git a/Screenshot from 2024-11-04 21-53-11.png b/Screenshot from 2024-11-04 21-53-11.png
new file mode 100644
index 0000000..ce30595
Binary files /dev/null and b/Screenshot from 2024-11-04 21-53-11.png differ