From 55a6322d8b0377daaa1501711be7f487e85d838c Mon Sep 17 00:00:00 2001
From: alidezhihui <ziliw0908@gmail.com>
Date: Tue, 27 May 2025 21:23:34 -0700
Subject: [PATCH] add(HW3): the first results

---
 HW3/main.ipynb | 1890 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1890 insertions(+)
 create mode 100644 HW3/main.ipynb

diff --git a/HW3/main.ipynb b/HW3/main.ipynb
new file mode 100644
index 0000000..a04b18e
--- /dev/null
+++ b/HW3/main.ipynb
@@ -0,0 +1,1890 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "924004b6",
+   "metadata": {},
+   "source": [
+    "# Method 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "initial_id",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-05-27T22:46:49.278440Z",
+     "start_time": "2025-05-27T22:46:45.221387Z"
+    },
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import random\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from PIL import Image\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "import torchvision.transforms as T\n",
+    "import torchvision.models as models\n",
+    "\n",
+    "import scipy.io"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "3f778ac16bf57769",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-05-27T22:46:49.291453Z",
+     "start_time": "2025-05-27T22:46:49.287444Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "IMG_DIR = './jpg'\n",
+    "LABEL_FILE = './imagelabels.mat'\n",
+    "SETID_FILE = './setid.mat'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "caf871b0fb93f758",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-05-27T22:46:49.309170Z",
+     "start_time": "2025-05-27T22:46:49.301966Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Total images: 8189\n",
+      "Train: 1020, Val: 1020, Test: 6149\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "os.environ['CUDA_LAUNCH_BLOCKING'] = '1'\n",
+    "\n",
+    "labels = scipy.io.loadmat(LABEL_FILE)['labels'][0] - 1\n",
+    "setids = scipy.io.loadmat(SETID_FILE)\n",
+    "train_ids = setids['trnid'][0] - 1\n",
+    "val_ids = setids['valid'][0] - 1\n",
+    "test_ids = setids['tstid'][0] - 1\n",
+    "\n",
+    "print(f\"Total images: {len(labels)}\")\n",
+    "print(f\"Train: {len(train_ids)}, Val: {len(val_ids)}, Test: {len(test_ids)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "6b289d12baa1647c",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-05-27T22:46:49.589282Z",
+     "start_time": "2025-05-27T22:46:49.585995Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class SimCLRTransform:\n",
+    "    def __init__(self, image_size=224):\n",
+    "        self.transform = T.Compose([\n",
+    "            T.RandomResizedCrop(image_size),\n",
+    "            T.RandomHorizontalFlip(),\n",
+    "            T.ColorJitter(0.8, 0.8, 0.8, 0.2),\n",
+    "            T.RandomGrayscale(p=0.2),\n",
+    "            T.GaussianBlur(kernel_size=9),\n",
+    "            T.ToTensor(),\n",
+    "            T.Normalize((0.5,), (0.5,))\n",
+    "        ])\n",
+    "\n",
+    "    def __call__(self, x):\n",
+    "        xi = self.transform(x)\n",
+    "        xj = self.transform(x)\n",
+    "        return xi, xj"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "32fc51832fc57892",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-05-27T22:46:49.600603Z",
+     "start_time": "2025-05-27T22:46:49.597604Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class FlowerSimCLRDataset(Dataset):\n",
+    "    def __init__(self, img_dir, indices, transform):\n",
+    "        self.img_dir = img_dir\n",
+    "        self.indices = indices\n",
+    "        self.transform = transform\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.indices)\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        img_id = self.indices[idx] + 1\n",
+    "        img_path = os.path.join(self.img_dir, f'image_{img_id:05d}.jpg')\n",
+    "        image = Image.open(img_path).convert(\"RGB\")\n",
+    "        return self.transform(image)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "57a6e1803481912b",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-05-27T22:46:49.664958Z",
+     "start_time": "2025-05-27T22:46:49.660958Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class SimCLR(nn.Module):\n",
+    "    def __init__(self, base_encoder='resnet18', projection_dim=128):\n",
+    "        super(SimCLR, self).__init__()\n",
+    "\n",
+    "        resnet = models.__dict__[base_encoder](pretrained=False)\n",
+    "        self.encoder = nn.Sequential(*list(resnet.children())[:-1])  # 去掉fc层\n",
+    "\n",
+    "        feat_dim = resnet.fc.in_features\n",
+    "\n",
+    "        self.projector = nn.Sequential(\n",
+    "            nn.Linear(feat_dim, feat_dim),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Linear(feat_dim, projection_dim)\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        h = self.encoder(x)\n",
+    "        h = h.squeeze()\n",
+    "        z = self.projector(h)\n",
+    "        z = F.normalize(z, dim=1)\n",
+    "        return z"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "df6cf7e3a682491a",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-05-27T22:46:49.681198Z",
+     "start_time": "2025-05-27T22:46:49.678787Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def nt_xent_loss(z_i, z_j, temperature=0.5):\n",
+    "    batch_size = z_i.shape[0]\n",
+    "    device = z_i.device\n",
+    "\n",
+    "    z = torch.cat([z_i, z_j], dim=0)\n",
+    "    z = F.normalize(z, dim=1)\n",
+    "\n",
+    "    similarity_matrix = torch.matmul(z, z.T)\n",
+    "\n",
+    "    labels = torch.cat([\n",
+    "        torch.arange(batch_size, 2 * batch_size),\n",
+    "        torch.arange(0, batch_size)\n",
+    "    ]).to(device)\n",
+    "\n",
+    "    mask = torch.eye(2 * batch_size, dtype=torch.bool).to(device)\n",
+    "    similarity_matrix = similarity_matrix.masked_fill(mask, -1e9)\n",
+    "\n",
+    "    similarity_matrix = similarity_matrix / temperature\n",
+    "\n",
+    "    loss = F.cross_entropy(similarity_matrix, labels)\n",
+    "    return loss\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "74440e0cd9b6183e",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-05-27T22:46:49.693585Z",
+     "start_time": "2025-05-27T22:46:49.689569Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def train_simclr(model, dataloader, optimizer, device, epochs=10):\n",
+    "    model.train()\n",
+    "    model.to(device)\n",
+    "\n",
+    "    for epoch in range(epochs):\n",
+    "        total_loss = 0\n",
+    "        for step, (xi, xj) in enumerate(tqdm(dataloader, desc=f\"Epoch {epoch+1}\")):\n",
+    "            xi, xj = xi.to(device), xj.to(device)\n",
+    "\n",
+    "            try:\n",
+    "                zi = model(xi)\n",
+    "                zj = model(xj)\n",
+    "\n",
+    "                loss = nt_xent_loss(zi, zj)\n",
+    "\n",
+    "                optimizer.zero_grad()\n",
+    "                loss.backward()\n",
+    "                optimizer.step()\n",
+    "\n",
+    "                total_loss += loss.item()\n",
+    "            except Exception as e:\n",
+    "                print(f\"[ERROR] at step {step}: {e}\")\n",
+    "                print(f\"xi shape: {xi.shape}, zi shape: {zi.shape}\")\n",
+    "                raise e\n",
+    "\n",
+    "        avg_loss = total_loss / len(dataloader)\n",
+    "        print(f\"Epoch {epoch+1}, Loss: {avg_loss:.4f}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "f0a4f257ff0b7ac7",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-05-27T22:48:35.843002Z",
+     "start_time": "2025-05-27T22:46:49.707842Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\29400\\anaconda3\\envs\\ecs260\\Lib\\site-packages\\torchvision\\models\\_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
+      "  warnings.warn(\n",
+      "C:\\Users\\29400\\anaconda3\\envs\\ecs260\\Lib\\site-packages\\torchvision\\models\\_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=None`.\n",
+      "  warnings.warn(msg)\n",
+      "Epoch 1: 100%|██████████| 16/16 [00:11<00:00,  1.37it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1, Loss: 4.8116\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 2: 100%|██████████| 16/16 [00:10<00:00,  1.50it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 2, Loss: 4.7826\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 3: 100%|██████████| 16/16 [00:10<00:00,  1.53it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 3, Loss: 4.7837\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 4: 100%|██████████| 16/16 [00:10<00:00,  1.54it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 4, Loss: 4.7575\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 5: 100%|██████████| 16/16 [00:10<00:00,  1.53it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 5, Loss: 4.7547\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 6: 100%|██████████| 16/16 [00:10<00:00,  1.54it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 6, Loss: 4.7490\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 7: 100%|██████████| 16/16 [00:10<00:00,  1.54it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 7, Loss: 4.7221\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 8: 100%|██████████| 16/16 [00:10<00:00,  1.52it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 8, Loss: 4.7303\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 9: 100%|██████████| 16/16 [00:10<00:00,  1.54it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 9, Loss: 4.7179\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 10: 100%|██████████| 16/16 [00:10<00:00,  1.51it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 10, Loss: 4.6700\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "transform = SimCLRTransform()\n",
+    "train_dataset = FlowerSimCLRDataset(IMG_DIR, train_ids, transform)\n",
+    "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=0)\n",
+    "\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "simclr = SimCLR(base_encoder='resnet18', projection_dim=128)\n",
+    "optimizer = torch.optim.Adam(simclr.parameters(), lr=3e-4)\n",
+    "\n",
+    "train_simclr(simclr, train_loader, optimizer, device, epochs=10)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f0f21f71ea89b5b9",
+   "metadata": {},
+   "source": [
+    "# 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "f9763aee4acf1d8d",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-05-27T22:48:35.884957Z",
+     "start_time": "2025-05-27T22:48:35.881920Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def get_frozen_encoder(simclr_model):\n",
+    "    encoder = simclr_model.encoder\n",
+    "    for param in encoder.parameters():\n",
+    "        param.requires_grad = False\n",
+    "    return encoder\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "d0689e54e750a9d",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-05-27T22:48:35.941952Z",
+     "start_time": "2025-05-27T22:48:35.938858Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class FlowerLabeledDataset(Dataset):\n",
+    "    def __init__(self, img_dir, indices, labels, transform=None):\n",
+    "        self.img_dir = img_dir\n",
+    "        self.indices = indices\n",
+    "        self.labels = labels\n",
+    "        self.transform = transform\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.indices)\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        img_id = self.indices[idx] + 1\n",
+    "        img_path = os.path.join(self.img_dir, f'image_{img_id:05d}.jpg')\n",
+    "        image = Image.open(img_path).convert(\"RGB\")\n",
+    "        label = self.labels[self.indices[idx]]\n",
+    "        if self.transform:\n",
+    "            image = self.transform(image)\n",
+    "        return image, label"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "5d3b8159f478e8e2",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-05-27T22:48:35.960643Z",
+     "start_time": "2025-05-27T22:48:35.957462Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class LinearClassifier(nn.Module):\n",
+    "    def __init__(self, encoder, feature_dim=512, num_classes=102):\n",
+    "        super().__init__()\n",
+    "        self.encoder = encoder\n",
+    "        self.fc = nn.Linear(feature_dim, num_classes)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        with torch.no_grad():\n",
+    "            h = self.encoder(x).squeeze()\n",
+    "        return self.fc(h)\n",
+    "\n",
+    "class MLPClassifier(nn.Module):\n",
+    "    def __init__(self, encoder, feature_dim=512, num_classes=102):\n",
+    "        super().__init__()\n",
+    "        self.encoder = encoder\n",
+    "        self.fc = nn.Sequential(\n",
+    "            nn.Linear(feature_dim, 256),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Linear(256, num_classes)\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        with torch.no_grad():\n",
+    "            h = self.encoder(x).squeeze()\n",
+    "        return self.fc(h)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "cc793cf8b33b126f",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-05-27T22:48:35.977337Z",
+     "start_time": "2025-05-27T22:48:35.972842Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def train_probe(model, train_loader, test_loader, device, epochs=10):\n",
+    "    model.to(device)\n",
+    "    optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n",
+    "    criterion = nn.CrossEntropyLoss()\n",
+    "\n",
+    "    for epoch in range(epochs):\n",
+    "        model.train()\n",
+    "        total_loss = 0\n",
+    "        correct = 0\n",
+    "\n",
+    "        for x, y in train_loader:\n",
+    "            x, y = x.to(device), y.to(device)\n",
+    "            logits = model(x)\n",
+    "            loss = criterion(logits, y)\n",
+    "\n",
+    "            optimizer.zero_grad()\n",
+    "            loss.backward()\n",
+    "            optimizer.step()\n",
+    "\n",
+    "            total_loss += loss.item()\n",
+    "            correct += (logits.argmax(1) == y).sum().item()\n",
+    "\n",
+    "        acc = correct / len(train_loader.dataset)\n",
+    "        print(f\"[Train] Epoch {epoch+1}: Loss = {total_loss:.4f}, Acc = {acc:.4f}\")\n",
+    "\n",
+    "        model.eval()\n",
+    "        correct = 0\n",
+    "        with torch.no_grad():\n",
+    "            for x, y in test_loader:\n",
+    "                x, y = x.to(device), y.to(device)\n",
+    "                logits = model(x)\n",
+    "                correct += (logits.argmax(1) == y).sum().item()\n",
+    "        val_acc = correct / len(test_loader.dataset)\n",
+    "        print(f\"[Val] Epoch {epoch+1}: Acc = {val_acc:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "1afe5656e03bc28e",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-05-27T22:51:05.378173Z",
+     "start_time": "2025-05-27T22:48:35.997342Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Linear Probe\n",
+      "[Train] Epoch 1: Loss = 73.9134, Acc = 0.0245\n",
+      "[Val] Epoch 1: Acc = 0.0510\n",
+      "[Train] Epoch 2: Loss = 63.5423, Acc = 0.0608\n",
+      "[Val] Epoch 2: Acc = 0.0784\n",
+      "[Train] Epoch 3: Loss = 60.3739, Acc = 0.0824\n",
+      "[Val] Epoch 3: Acc = 0.1000\n",
+      "[Train] Epoch 4: Loss = 58.4654, Acc = 0.0990\n",
+      "[Val] Epoch 4: Acc = 0.0990\n",
+      "[Train] Epoch 5: Loss = 57.4966, Acc = 0.1176\n",
+      "[Val] Epoch 5: Acc = 0.1108\n",
+      "[Train] Epoch 6: Loss = 57.1761, Acc = 0.1118\n",
+      "[Val] Epoch 6: Acc = 0.1186\n",
+      "[Train] Epoch 7: Loss = 56.5777, Acc = 0.1157\n",
+      "[Val] Epoch 7: Acc = 0.1284\n",
+      "[Train] Epoch 8: Loss = 55.9389, Acc = 0.1294\n",
+      "[Val] Epoch 8: Acc = 0.0951\n",
+      "[Train] Epoch 9: Loss = 55.1261, Acc = 0.1343\n",
+      "[Val] Epoch 9: Acc = 0.1196\n",
+      "[Train] Epoch 10: Loss = 54.5212, Acc = 0.1520\n",
+      "[Val] Epoch 10: Acc = 0.1186\n",
+      "MLP\n",
+      "[Train] Epoch 1: Loss = 72.5186, Acc = 0.0137\n",
+      "[Val] Epoch 1: Acc = 0.0569\n",
+      "[Train] Epoch 2: Loss = 65.1633, Acc = 0.0529\n",
+      "[Val] Epoch 2: Acc = 0.0627\n",
+      "[Train] Epoch 3: Loss = 61.4982, Acc = 0.0725\n",
+      "[Val] Epoch 3: Acc = 0.0784\n",
+      "[Train] Epoch 4: Loss = 59.2857, Acc = 0.0804\n",
+      "[Val] Epoch 4: Acc = 0.0696\n",
+      "[Train] Epoch 5: Loss = 58.2057, Acc = 0.1000\n",
+      "[Val] Epoch 5: Acc = 0.1029\n",
+      "[Train] Epoch 6: Loss = 56.6923, Acc = 0.1088\n",
+      "[Val] Epoch 6: Acc = 0.0941\n",
+      "[Train] Epoch 7: Loss = 56.2853, Acc = 0.1147\n",
+      "[Val] Epoch 7: Acc = 0.1020\n",
+      "[Train] Epoch 8: Loss = 55.0567, Acc = 0.1225\n",
+      "[Val] Epoch 8: Acc = 0.0873\n",
+      "[Train] Epoch 9: Loss = 54.6421, Acc = 0.1520\n",
+      "[Val] Epoch 9: Acc = 0.1000\n",
+      "[Train] Epoch 10: Loss = 53.7336, Acc = 0.1382\n",
+      "[Val] Epoch 10: Acc = 0.0931\n"
+     ]
+    }
+   ],
+   "source": [
+    "probe_transform = T.Compose([\n",
+    "    T.Resize(256),\n",
+    "    T.CenterCrop(224),\n",
+    "    T.ToTensor(),\n",
+    "    T.Normalize((0.5,), (0.5,))\n",
+    "])\n",
+    "\n",
+    "train_probe_dataset = FlowerLabeledDataset(IMG_DIR, train_ids, labels, probe_transform)\n",
+    "val_probe_dataset = FlowerLabeledDataset(IMG_DIR, val_ids, labels, probe_transform)\n",
+    "train_probe_loader = DataLoader(train_probe_dataset, batch_size=64, shuffle=True)\n",
+    "val_probe_loader = DataLoader(val_probe_dataset, batch_size=64)\n",
+    "\n",
+    "encoder = get_frozen_encoder(simclr)\n",
+    "probe_model = LinearClassifier(encoder)\n",
+    "\n",
+    "print(\"Linear Probe\")\n",
+    "train_probe(probe_model, train_probe_loader, val_probe_loader, device, epochs=10)\n",
+    "\n",
+    "print(\"MLP\")\n",
+    "mlp_model = MLPClassifier(encoder)\n",
+    "train_probe(mlp_model, train_probe_loader, val_probe_loader, device, epochs=10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "eb04a09b20c85f44",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-05-27T22:51:47.106568Z",
+     "start_time": "2025-05-27T22:51:46.967206Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "epochs = list(range(1, 11))\n",
+    "\n",
+    "linear_train_acc = [0.0265, 0.0706, 0.1020, 0.1294, 0.1265, 0.1373, 0.1304, 0.1608, 0.1667, 0.1647]\n",
+    "linear_val_acc   = [0.0608, 0.0941, 0.1127, 0.1167, 0.1167, 0.1461, 0.1225, 0.1314, 0.1373, 0.1441]\n",
+    "\n",
+    "mlp_train_acc = [0.0137, 0.0529, 0.0725, 0.0804, 0.1000, 0.1088, 0.1147, 0.1225, 0.1520, 0.1382]\n",
+    "mlp_val_acc   = [0.0569, 0.0627, 0.0784, 0.0696, 0.1029, 0.0941, 0.1020, 0.0873, 0.1000, 0.0931]\n",
+    "\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "plt.plot(epochs, linear_train_acc, label='Train Accuracy', marker='o')\n",
+    "plt.plot(epochs, linear_val_acc, label='Validation Accuracy', marker='s', linestyle='--')\n",
+    "plt.title('SimCLR Linear Probe Accuracy over Epochs')\n",
+    "plt.xlabel('Epoch')\n",
+    "plt.ylabel('Accuracy')\n",
+    "plt.xticks(epochs)\n",
+    "plt.grid(True)\n",
+    "plt.legend()\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "plt.plot(epochs, mlp_train_acc, label='Train Accuracy', marker='o')\n",
+    "plt.plot(epochs, mlp_val_acc, label='Validation Accuracy', marker='s', linestyle='--')\n",
+    "plt.title('SimCLR MLP Classifier Accuracy over Epochs')\n",
+    "plt.xlabel('Epoch')\n",
+    "plt.ylabel('Accuracy')\n",
+    "plt.xticks(epochs)\n",
+    "plt.grid(True)\n",
+    "plt.legend()\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2a814c521e725a23",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-05-27T22:51:05.510718Z",
+     "start_time": "2025-05-27T22:51:05.508501Z"
+    }
+   },
+   "source": [
+    "# Method 2: Masked Autoencoder (MAE with Vision Transformer)\n",
+    "\n",
+    "In summary, MAE masks a large portion of image patches and learns to reconstruct the missing patches from the visible ones. The encoder is a Vision Transformer, with a lightweight transformer decoder."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "07c1c5ae",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Requirement already satisfied: timm in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (1.0.15)\n",
+      "Requirement already satisfied: torchvision in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from timm) (0.19.1)\n",
+      "Requirement already satisfied: safetensors in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from timm) (0.5.3)\n",
+      "Requirement already satisfied: pyyaml in /usr/lib/python3/dist-packages (from timm) (5.3.1)\n",
+      "Requirement already satisfied: torch in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from timm) (2.4.1)\n",
+      "Requirement already satisfied: huggingface_hub in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from timm) (0.32.1)\n",
+      "Requirement already satisfied: numpy in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from torchvision->timm) (1.24.4)\n",
+      "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/lib/python3/dist-packages (from torchvision->timm) (7.0.0)\n",
+      "Requirement already satisfied: jinja2 in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from torch->timm) (3.1.6)\n",
+      "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\" in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from torch->timm) (12.1.105)\n",
+      "Requirement already satisfied: triton==3.0.0; platform_system == \"Linux\" and platform_machine == \"x86_64\" and python_version < \"3.13\" in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from torch->timm) (3.0.0)\n",
+      "Requirement already satisfied: nvidia-cudnn-cu12==9.1.0.70; platform_system == \"Linux\" and platform_machine == \"x86_64\" in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from torch->timm) (9.1.0.70)\n",
+      "Requirement already satisfied: nvidia-cufft-cu12==11.0.2.54; platform_system == \"Linux\" and platform_machine == \"x86_64\" in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from torch->timm) (11.0.2.54)\n",
+      "Requirement already satisfied: nvidia-cusolver-cu12==11.4.5.107; platform_system == \"Linux\" and platform_machine == \"x86_64\" in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from torch->timm) (11.4.5.107)\n",
+      "Requirement already satisfied: typing-extensions>=4.8.0 in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from torch->timm) (4.13.2)\n",
+      "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\" in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from torch->timm) (12.1.105)\n",
+      "Requirement already satisfied: fsspec in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from torch->timm) (2025.3.0)\n",
+      "Requirement already satisfied: nvidia-nvtx-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\" in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from torch->timm) (12.1.105)\n",
+      "Requirement already satisfied: nvidia-cusparse-cu12==12.1.0.106; platform_system == \"Linux\" and platform_machine == \"x86_64\" in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from torch->timm) (12.1.0.106)\n",
+      "Requirement already satisfied: sympy in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from torch->timm) (1.13.3)\n",
+      "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\" in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from torch->timm) (12.1.105)\n",
+      "Requirement already satisfied: networkx in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from torch->timm) (3.1)\n",
+      "Requirement already satisfied: nvidia-curand-cu12==10.3.2.106; platform_system == \"Linux\" and platform_machine == \"x86_64\" in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from torch->timm) (10.3.2.106)\n",
+      "Requirement already satisfied: filelock in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from torch->timm) (3.16.1)\n",
+      "Requirement already satisfied: nvidia-cublas-cu12==12.1.3.1; platform_system == \"Linux\" and platform_machine == \"x86_64\" in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from torch->timm) (12.1.3.1)\n",
+      "Requirement already satisfied: nvidia-nccl-cu12==2.20.5; platform_system == \"Linux\" and platform_machine == \"x86_64\" in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from torch->timm) (2.20.5)\n",
+      "Requirement already satisfied: tqdm>=4.42.1 in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from huggingface_hub->timm) (4.67.1)\n",
+      "Requirement already satisfied: packaging>=20.9 in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from huggingface_hub->timm) (25.0)\n",
+      "Requirement already satisfied: hf-xet<2.0.0,>=1.1.2; platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"arm64\" or platform_machine == \"aarch64\" in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from huggingface_hub->timm) (1.1.2)\n",
+      "Requirement already satisfied: requests in /usr/lib/python3/dist-packages (from huggingface_hub->timm) (2.22.0)\n",
+      "Requirement already satisfied: MarkupSafe>=2.0 in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from jinja2->torch->timm) (2.1.5)\n",
+      "Requirement already satisfied: nvidia-nvjitlink-cu12 in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from nvidia-cusolver-cu12==11.4.5.107; platform_system == \"Linux\" and platform_machine == \"x86_64\"->torch->timm) (12.9.41)\n",
+      "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from sympy->torch->timm) (1.3.0)\n",
+      "Note: you may need to restart the kernel to use updated packages.\n",
+      "Requirement already satisfied: scipy in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (1.10.1)\n",
+      "Requirement already satisfied: numpy<1.27.0,>=1.19.5 in /opt/nfs/home/zliwang/.local/lib/python3.8/site-packages (from scipy) (1.24.4)\n",
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "%pip install timm\n",
+    "%pip install scipy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "2009379d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from torch.utils.data import DataLoader\n",
+    "from torchvision.datasets import Flowers102\n",
+    "from torchvision import transforms\n",
+    "import timm\n",
+    "import argparse\n",
+    "\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "\n",
+    "# Data Loading\n",
+    "def get_data_loaders(batch_size=64):\n",
+    "    transform = transforms.Compose([\n",
+    "        transforms.Resize(224),\n",
+    "        transforms.CenterCrop(224),\n",
+    "        transforms.ToTensor(),\n",
+    "    ])\n",
+    "    train_dataset = Flowers102(root=\"./data\", split=\"train\", transform=transform, download=True)\n",
+    "    val_dataset = Flowers102(root=\"./data\", split=\"val\", transform=transform, download=True)\n",
+    "    test_dataset = Flowers102(root=\"./data\", split=\"test\", transform=transform, download=True)\n",
+    "\n",
+    "    from torch.utils.data import ConcatDataset\n",
+    "    # Why combine train and val?\n",
+    "    # 1. small size of training set\n",
+    "    # 2. We are not tunning hyperparameters for this model; our goal is probing representation quality\n",
+    "    train_dataset = ConcatDataset([train_dataset, val_dataset])\n",
+    "    print(\"size of training set: \", len(train_dataset))\n",
+    "    print(\"size of test set: \", len(test_dataset))\n",
+    "    train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
+    "    test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n",
+    "    return train_loader, test_loader, len(set(train_dataset.datasets[0]._labels))\n",
+    "\n",
+    "# MAE-based ViT Encoder using pretrained weights from timm\n",
+    "def get_mae_encoder():\n",
+    "    encoder = timm.create_model(\"vit_base_patch16_224.mae\", pretrained=True)\n",
+    "    encoder.head = nn.Identity()  # Remove classification head to use encoder only\n",
+    "    encoder.eval()\n",
+    "    return encoder\n",
+    "\n",
+    "# Probes\n",
+    "class LinearProbe(nn.Module):\n",
+    "    def __init__(self, encoder, feature_dim, num_classes):\n",
+    "        super().__init__()\n",
+    "        self.encoder = encoder\n",
+    "        self.classifier = nn.Linear(feature_dim, num_classes)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        with torch.no_grad():\n",
+    "            x = self.encoder(x)\n",
+    "        return self.classifier(x)\n",
+    "\n",
+    "class MLPProbe(nn.Module):\n",
+    "    def __init__(self, encoder, feature_dim, num_classes):\n",
+    "        super().__init__()\n",
+    "        self.encoder = encoder\n",
+    "        self.classifier = nn.Sequential(\n",
+    "            nn.Linear(feature_dim, 512),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Linear(512, num_classes)\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        with torch.no_grad():\n",
+    "            x = self.encoder(x)\n",
+    "        return self.classifier(x)\n",
+    "\n",
+    "# Training\n",
+    "def train_probe(model, train_loader, test_loader, num_epochs=10):\n",
+    "    def eval_probe(model, at_epoch: int):\n",
+    "        # Evaluation\n",
+    "        model.eval()\n",
+    "        correct, total = 0, 0\n",
+    "        with torch.no_grad():\n",
+    "            for images, labels in test_loader:\n",
+    "                images, labels = images.to(device), labels.to(device)\n",
+    "                outputs = model(images)\n",
+    "                predicted = torch.argmax(outputs, dim=1)\n",
+    "                correct += (predicted == labels).sum().item()\n",
+    "                total += labels.size(0)\n",
+    "\n",
+    "        print(f\"\\n----------At epoch {at_epoch}-------------\")\n",
+    "        print(f\"Test Accuracy: {100 * correct / total:.2f}%\")\n",
+    "        print(f\"\\n------------------------------------------\\n\\n\")\n",
+    "        \n",
+    "\n",
+    "    model.to(device)\n",
+    "    criterion = nn.CrossEntropyLoss()\n",
+    "    optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)\n",
+    "\n",
+    "    for epoch in range(num_epochs):\n",
+    "        model.train()\n",
+    "        total_loss = 0\n",
+    "        for images, labels in train_loader:\n",
+    "            images, labels = images.to(device), labels.to(device)\n",
+    "            outputs = model(images)\n",
+    "            loss = criterion(outputs, labels)\n",
+    "\n",
+    "            optimizer.zero_grad()\n",
+    "            loss.backward()\n",
+    "            optimizer.step()\n",
+    "            total_loss += loss.item()\n",
+    "\n",
+    "        print(f\"Epoch {epoch+1}/{num_epochs}, Loss: {total_loss/len(train_loader):.4f}\")\n",
+    "        if ((epoch + 1) % 10) == 0 and epoch != 0:\n",
+    "            eval_probe(model, epoch)\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "# Main\n",
+    "def main(probe_type=\"linear\", epochs=10):\n",
+    "    train_loader, test_loader, num_classes = get_data_loaders()\n",
+    "    encoder = get_mae_encoder()\n",
+    "    feature_dim = encoder.num_features\n",
+    "\n",
+    "    if probe_type == \"linear\":\n",
+    "        model = LinearProbe(encoder, feature_dim, num_classes)\n",
+    "    else:\n",
+    "        model = MLPProbe(encoder, feature_dim, num_classes)\n",
+    "\n",
+    "    train_probe(model, train_loader, test_loader, num_epochs=epochs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "702812b5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "size of training set:  2040\n",
+      "size of test set:  6149\n",
+      "Epoch 1/10, Loss: 4.6814\n",
+      "Epoch 2/10, Loss: 4.6382\n",
+      "Epoch 3/10, Loss: 4.6057\n",
+      "Epoch 4/10, Loss: 4.5763\n",
+      "Epoch 5/10, Loss: 4.5499\n",
+      "Epoch 6/10, Loss: 4.5255\n",
+      "Epoch 7/10, Loss: 4.5018\n",
+      "Epoch 8/10, Loss: 4.4788\n",
+      "Epoch 9/10, Loss: 4.4562\n",
+      "Epoch 10/10, Loss: 4.4346\n",
+      "Test Accuracy: 20.25%\n"
+     ]
+    }
+   ],
+   "source": [
+    "linear_model = main(\"linear\", 10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "383cada7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "size of training set:  2040\n",
+      "size of test set:  6149\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/10, Loss: 4.6287\n",
+      "Epoch 2/10, Loss: 4.5946\n",
+      "Epoch 3/10, Loss: 4.5617\n",
+      "Epoch 4/10, Loss: 4.5244\n",
+      "Epoch 5/10, Loss: 4.4809\n",
+      "Epoch 6/10, Loss: 4.4322\n",
+      "Epoch 7/10, Loss: 4.3794\n",
+      "Epoch 8/10, Loss: 4.3218\n",
+      "Epoch 9/10, Loss: 4.2625\n",
+      "Epoch 10/10, Loss: 4.1997\n",
+      "Test Accuracy: 21.63%\n"
+     ]
+    }
+   ],
+   "source": [
+    "mlp_model = main(\"mlp\", 10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "02b01a39",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "size of training set:  2040\n",
+      "size of test set:  6149\n",
+      "Epoch 1/100, Loss: 4.6817\n",
+      "Epoch 2/100, Loss: 4.6355\n",
+      "Epoch 3/100, Loss: 4.5991\n",
+      "Epoch 4/100, Loss: 4.5686\n",
+      "Epoch 5/100, Loss: 4.5411\n",
+      "Epoch 6/100, Loss: 4.5162\n",
+      "Epoch 7/100, Loss: 4.4919\n",
+      "Epoch 8/100, Loss: 4.4689\n",
+      "Epoch 9/100, Loss: 4.4464\n",
+      "Epoch 10/100, Loss: 4.4250\n",
+      "Epoch 11/100, Loss: 4.4034\n",
+      "\n",
+      "----------At epoch 10-------------\n",
+      "Test Accuracy: 22.08%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 12/100, Loss: 4.3824\n",
+      "Epoch 13/100, Loss: 4.3616\n",
+      "Epoch 14/100, Loss: 4.3407\n",
+      "Epoch 15/100, Loss: 4.3205\n",
+      "Epoch 16/100, Loss: 4.3007\n",
+      "Epoch 17/100, Loss: 4.2806\n",
+      "Epoch 18/100, Loss: 4.2606\n",
+      "Epoch 19/100, Loss: 4.2407\n",
+      "Epoch 20/100, Loss: 4.2209\n",
+      "Epoch 21/100, Loss: 4.2019\n",
+      "\n",
+      "----------At epoch 20-------------\n",
+      "Test Accuracy: 36.77%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 22/100, Loss: 4.1825\n",
+      "Epoch 23/100, Loss: 4.1635\n",
+      "Epoch 24/100, Loss: 4.1443\n",
+      "Epoch 25/100, Loss: 4.1257\n",
+      "Epoch 26/100, Loss: 4.1067\n",
+      "Epoch 27/100, Loss: 4.0885\n",
+      "Epoch 28/100, Loss: 4.0700\n",
+      "Epoch 29/100, Loss: 4.0520\n",
+      "Epoch 30/100, Loss: 4.0339\n",
+      "Epoch 31/100, Loss: 4.0164\n",
+      "\n",
+      "----------At epoch 30-------------\n",
+      "Test Accuracy: 42.64%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 32/100, Loss: 3.9989\n",
+      "Epoch 33/100, Loss: 3.9810\n",
+      "Epoch 34/100, Loss: 3.9632\n",
+      "Epoch 35/100, Loss: 3.9457\n",
+      "Epoch 36/100, Loss: 3.9281\n",
+      "Epoch 37/100, Loss: 3.9113\n",
+      "Epoch 38/100, Loss: 3.8946\n",
+      "Epoch 39/100, Loss: 3.8780\n",
+      "Epoch 40/100, Loss: 3.8611\n",
+      "Epoch 41/100, Loss: 3.8446\n",
+      "\n",
+      "----------At epoch 40-------------\n",
+      "Test Accuracy: 46.54%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 42/100, Loss: 3.8283\n",
+      "Epoch 43/100, Loss: 3.8120\n",
+      "Epoch 44/100, Loss: 3.7960\n",
+      "Epoch 45/100, Loss: 3.7797\n",
+      "Epoch 46/100, Loss: 3.7637\n",
+      "Epoch 47/100, Loss: 3.7476\n",
+      "Epoch 48/100, Loss: 3.7321\n",
+      "Epoch 49/100, Loss: 3.7166\n",
+      "Epoch 50/100, Loss: 3.7007\n",
+      "Epoch 51/100, Loss: 3.6860\n",
+      "\n",
+      "----------At epoch 50-------------\n",
+      "Test Accuracy: 49.03%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 52/100, Loss: 3.6706\n",
+      "Epoch 53/100, Loss: 3.6560\n",
+      "Epoch 54/100, Loss: 3.6406\n",
+      "Epoch 55/100, Loss: 3.6240\n",
+      "Epoch 56/100, Loss: 3.6108\n",
+      "Epoch 57/100, Loss: 3.5953\n",
+      "Epoch 58/100, Loss: 3.5812\n",
+      "Epoch 59/100, Loss: 3.5667\n",
+      "Epoch 60/100, Loss: 3.5522\n",
+      "Epoch 61/100, Loss: 3.5377\n",
+      "\n",
+      "----------At epoch 60-------------\n",
+      "Test Accuracy: 50.67%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 62/100, Loss: 3.5235\n",
+      "Epoch 63/100, Loss: 3.5093\n",
+      "Epoch 64/100, Loss: 3.4956\n",
+      "Epoch 65/100, Loss: 3.4820\n",
+      "Epoch 66/100, Loss: 3.4675\n",
+      "Epoch 67/100, Loss: 3.4547\n",
+      "Epoch 68/100, Loss: 3.4403\n",
+      "Epoch 69/100, Loss: 3.4271\n",
+      "Epoch 70/100, Loss: 3.4139\n",
+      "Epoch 71/100, Loss: 3.3997\n",
+      "\n",
+      "----------At epoch 70-------------\n",
+      "Test Accuracy: 51.73%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 72/100, Loss: 3.3863\n",
+      "Epoch 73/100, Loss: 3.3735\n",
+      "Epoch 74/100, Loss: 3.3602\n",
+      "Epoch 75/100, Loss: 3.3479\n",
+      "Epoch 76/100, Loss: 3.3345\n",
+      "Epoch 77/100, Loss: 3.3211\n",
+      "Epoch 78/100, Loss: 3.3088\n",
+      "Epoch 79/100, Loss: 3.2961\n",
+      "Epoch 80/100, Loss: 3.2841\n",
+      "Epoch 81/100, Loss: 3.2710\n",
+      "\n",
+      "----------At epoch 80-------------\n",
+      "Test Accuracy: 53.41%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 82/100, Loss: 3.2589\n",
+      "Epoch 83/100, Loss: 3.2462\n",
+      "Epoch 84/100, Loss: 3.2343\n",
+      "Epoch 85/100, Loss: 3.2222\n",
+      "Epoch 86/100, Loss: 3.2094\n",
+      "Epoch 87/100, Loss: 3.1971\n",
+      "Epoch 88/100, Loss: 3.1853\n",
+      "Epoch 89/100, Loss: 3.1734\n",
+      "Epoch 90/100, Loss: 3.1623\n",
+      "Epoch 91/100, Loss: 3.1500\n",
+      "\n",
+      "----------At epoch 90-------------\n",
+      "Test Accuracy: 54.77%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 92/100, Loss: 3.1389\n",
+      "Epoch 93/100, Loss: 3.1269\n",
+      "Epoch 94/100, Loss: 3.1154\n",
+      "Epoch 95/100, Loss: 3.1036\n",
+      "Epoch 96/100, Loss: 3.0932\n",
+      "Epoch 97/100, Loss: 3.0815\n",
+      "Epoch 98/100, Loss: 3.0699\n",
+      "Epoch 99/100, Loss: 3.0587\n",
+      "Epoch 100/100, Loss: 3.0477\n"
+     ]
+    }
+   ],
+   "source": [
+    "linear_model = main(\"linear\", 100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "75ff7159",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "size of training set:  2040\n",
+      "size of test set:  6149\n",
+      "Epoch 1/100, Loss: 4.6281\n",
+      "Epoch 2/100, Loss: 4.5930\n",
+      "Epoch 3/100, Loss: 4.5592\n",
+      "Epoch 4/100, Loss: 4.5199\n",
+      "Epoch 5/100, Loss: 4.4748\n",
+      "Epoch 6/100, Loss: 4.4245\n",
+      "Epoch 7/100, Loss: 4.3697\n",
+      "Epoch 8/100, Loss: 4.3126\n",
+      "Epoch 9/100, Loss: 4.2499\n",
+      "Epoch 10/100, Loss: 4.1853\n",
+      "Epoch 11/100, Loss: 4.1211\n",
+      "\n",
+      "----------At epoch 10-------------\n",
+      "Test Accuracy: 18.77%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 12/100, Loss: 4.0543\n",
+      "Epoch 13/100, Loss: 3.9879\n",
+      "Epoch 14/100, Loss: 3.9226\n",
+      "Epoch 15/100, Loss: 3.8584\n",
+      "Epoch 16/100, Loss: 3.7943\n",
+      "Epoch 17/100, Loss: 3.7317\n",
+      "Epoch 18/100, Loss: 3.6714\n",
+      "Epoch 19/100, Loss: 3.6105\n",
+      "Epoch 20/100, Loss: 3.5537\n",
+      "Epoch 21/100, Loss: 3.4969\n",
+      "\n",
+      "----------At epoch 20-------------\n",
+      "Test Accuracy: 27.32%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 22/100, Loss: 3.4383\n",
+      "Epoch 23/100, Loss: 3.3839\n",
+      "Epoch 24/100, Loss: 3.3325\n",
+      "Epoch 25/100, Loss: 3.2801\n",
+      "Epoch 26/100, Loss: 3.2310\n",
+      "Epoch 27/100, Loss: 3.1819\n",
+      "Epoch 28/100, Loss: 3.1355\n",
+      "Epoch 29/100, Loss: 3.0893\n",
+      "Epoch 30/100, Loss: 3.0448\n",
+      "Epoch 31/100, Loss: 3.0035\n",
+      "\n",
+      "----------At epoch 30-------------\n",
+      "Test Accuracy: 34.92%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 32/100, Loss: 2.9586\n",
+      "Epoch 33/100, Loss: 2.9180\n",
+      "Epoch 34/100, Loss: 2.8784\n",
+      "Epoch 35/100, Loss: 2.8398\n",
+      "Epoch 36/100, Loss: 2.7998\n",
+      "Epoch 37/100, Loss: 2.7651\n",
+      "Epoch 38/100, Loss: 2.7286\n",
+      "Epoch 39/100, Loss: 2.6933\n",
+      "Epoch 40/100, Loss: 2.6567\n",
+      "Epoch 41/100, Loss: 2.6261\n",
+      "\n",
+      "----------At epoch 40-------------\n",
+      "Test Accuracy: 40.45%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 42/100, Loss: 2.5945\n",
+      "Epoch 43/100, Loss: 2.5603\n",
+      "Epoch 44/100, Loss: 2.5274\n",
+      "Epoch 45/100, Loss: 2.4977\n",
+      "Epoch 46/100, Loss: 2.4695\n",
+      "Epoch 47/100, Loss: 2.4377\n",
+      "Epoch 48/100, Loss: 2.4079\n",
+      "Epoch 49/100, Loss: 2.3795\n",
+      "Epoch 50/100, Loss: 2.3511\n",
+      "Epoch 51/100, Loss: 2.3262\n",
+      "\n",
+      "----------At epoch 50-------------\n",
+      "Test Accuracy: 45.16%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 52/100, Loss: 2.3005\n",
+      "Epoch 53/100, Loss: 2.2738\n",
+      "Epoch 54/100, Loss: 2.2474\n",
+      "Epoch 55/100, Loss: 2.2225\n",
+      "Epoch 56/100, Loss: 2.1976\n",
+      "Epoch 57/100, Loss: 2.1739\n",
+      "Epoch 58/100, Loss: 2.1510\n",
+      "Epoch 59/100, Loss: 2.1278\n",
+      "Epoch 60/100, Loss: 2.1048\n",
+      "Epoch 61/100, Loss: 2.0829\n",
+      "\n",
+      "----------At epoch 60-------------\n",
+      "Test Accuracy: 48.58%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 62/100, Loss: 2.0594\n",
+      "Epoch 63/100, Loss: 2.0391\n",
+      "Epoch 64/100, Loss: 2.0193\n",
+      "Epoch 65/100, Loss: 1.9976\n",
+      "Epoch 66/100, Loss: 1.9763\n",
+      "Epoch 67/100, Loss: 1.9586\n",
+      "Epoch 68/100, Loss: 1.9399\n",
+      "Epoch 69/100, Loss: 1.9176\n",
+      "Epoch 70/100, Loss: 1.8974\n",
+      "Epoch 71/100, Loss: 1.8808\n",
+      "\n",
+      "----------At epoch 70-------------\n",
+      "Test Accuracy: 51.49%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 72/100, Loss: 1.8590\n",
+      "Epoch 73/100, Loss: 1.8437\n",
+      "Epoch 74/100, Loss: 1.8273\n",
+      "Epoch 75/100, Loss: 1.8083\n",
+      "Epoch 76/100, Loss: 1.7929\n",
+      "Epoch 77/100, Loss: 1.7733\n",
+      "Epoch 78/100, Loss: 1.7567\n",
+      "Epoch 79/100, Loss: 1.7409\n",
+      "Epoch 80/100, Loss: 1.7237\n",
+      "Epoch 81/100, Loss: 1.7071\n",
+      "\n",
+      "----------At epoch 80-------------\n",
+      "Test Accuracy: 54.04%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 82/100, Loss: 1.6958\n",
+      "Epoch 83/100, Loss: 1.6773\n",
+      "Epoch 84/100, Loss: 1.6625\n",
+      "Epoch 85/100, Loss: 1.6482\n",
+      "Epoch 86/100, Loss: 1.6301\n",
+      "Epoch 87/100, Loss: 1.6183\n",
+      "Epoch 88/100, Loss: 1.6041\n",
+      "Epoch 89/100, Loss: 1.5890\n",
+      "Epoch 90/100, Loss: 1.5772\n",
+      "Epoch 91/100, Loss: 1.5602\n",
+      "\n",
+      "----------At epoch 90-------------\n",
+      "Test Accuracy: 56.20%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 92/100, Loss: 1.5459\n",
+      "Epoch 93/100, Loss: 1.5323\n",
+      "Epoch 94/100, Loss: 1.5190\n",
+      "Epoch 95/100, Loss: 1.5077\n",
+      "Epoch 96/100, Loss: 1.4933\n",
+      "Epoch 97/100, Loss: 1.4826\n",
+      "Epoch 98/100, Loss: 1.4676\n",
+      "Epoch 99/100, Loss: 1.4589\n",
+      "Epoch 100/100, Loss: 1.4431\n"
+     ]
+    }
+   ],
+   "source": [
+    "mlp_model = main(\"mlp\", 100)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f7437ab3",
+   "metadata": {},
+   "source": [
+    "The above sections try to train the classifer solely. Below, train both encoder and classifier together"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "88630e07",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from torch.utils.data import DataLoader\n",
+    "from torchvision.datasets import Flowers102\n",
+    "from torchvision import transforms\n",
+    "import timm\n",
+    "import argparse\n",
+    "\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "\n",
+    "# Data Loading\n",
+    "def get_data_loaders(batch_size=64):\n",
+    "    transform = transforms.Compose([\n",
+    "        transforms.Resize(224),\n",
+    "        transforms.CenterCrop(224),\n",
+    "        transforms.ToTensor(),\n",
+    "    ])\n",
+    "    train_dataset = Flowers102(root=\"./data\", split=\"train\", transform=transform, download=True)\n",
+    "    val_dataset = Flowers102(root=\"./data\", split=\"val\", transform=transform, download=True)\n",
+    "    test_dataset = Flowers102(root=\"./data\", split=\"test\", transform=transform, download=True)\n",
+    "\n",
+    "    from torch.utils.data import ConcatDataset\n",
+    "    # Why combine train and val?\n",
+    "    # 1. small size of training set\n",
+    "    # 2. We are not tunning hyperparameters for this model; our goal is probing representation quality\n",
+    "    train_dataset = ConcatDataset([train_dataset, val_dataset])\n",
+    "\n",
+    "    train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
+    "    test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n",
+    "    return train_loader, test_loader, len(set(train_dataset.datasets[0]._labels))\n",
+    "\n",
+    "# MAE-based ViT Encoder using pretrained weights from timm\n",
+    "def get_mae_encoder():\n",
+    "    encoder = timm.create_model(\"vit_base_patch16_224.mae\", pretrained=True)\n",
+    "    encoder.head = nn.Identity()  # Remove classification head to use encoder only\n",
+    "    encoder.train()\n",
+    "    return encoder\n",
+    "\n",
+    "# Probes\n",
+    "class LinearProbe(nn.Module):\n",
+    "    def __init__(self, encoder, feature_dim, num_classes):\n",
+    "        super().__init__()\n",
+    "        self.encoder = encoder\n",
+    "        self.classifier = nn.Linear(feature_dim, num_classes)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.encoder(x)\n",
+    "        return self.classifier(x)\n",
+    "\n",
+    "class MLPProbe(nn.Module):\n",
+    "    def __init__(self, encoder, feature_dim, num_classes):\n",
+    "        super().__init__()\n",
+    "        self.encoder = encoder\n",
+    "        self.classifier = nn.Sequential(\n",
+    "            nn.Linear(feature_dim, 512),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Linear(512, num_classes)\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.encoder(x)\n",
+    "        return self.classifier(x)\n",
+    "\n",
+    "# Training\n",
+    "def train_probe(model, train_loader, test_loader, num_epochs=10):\n",
+    "    def eval_probe(model, at_epoch: int):\n",
+    "            # Evaluation\n",
+    "        model.eval()\n",
+    "        correct, total = 0, 0\n",
+    "        with torch.no_grad():\n",
+    "            for images, labels in test_loader:\n",
+    "                images, labels = images.to(device), labels.to(device)\n",
+    "                outputs = model(images)\n",
+    "                predicted = torch.argmax(outputs, dim=1)\n",
+    "                correct += (predicted == labels).sum().item()\n",
+    "                total += labels.size(0)\n",
+    "        print(f\"\\n----------At epoch {at_epoch}-------------\")\n",
+    "        print(f\"Test Accuracy: {100 * correct / total:.2f}%\")\n",
+    "        print(f\"\\n------------------------------------------\\n\\n\")\n",
+    "\n",
+    "    model.to(device)\n",
+    "    criterion = nn.CrossEntropyLoss()\n",
+    "    optimizer = torch.optim.Adam(model.classifier.parameters(), lr=1e-3)\n",
+    "\n",
+    "    for epoch in range(num_epochs):\n",
+    "        model.train()\n",
+    "        total_loss = 0\n",
+    "        for images, labels in train_loader:\n",
+    "            images, labels = images.to(device), labels.to(device)\n",
+    "            outputs = model(images)\n",
+    "            loss = criterion(outputs, labels)\n",
+    "\n",
+    "            optimizer.zero_grad()\n",
+    "            loss.backward()\n",
+    "            optimizer.step()\n",
+    "            total_loss += loss.item()\n",
+    "\n",
+    "        print(f\"Epoch {epoch+1}/{num_epochs}, Loss: {total_loss/len(train_loader):.4f}\")\n",
+    "        if ((epoch + 1) % 10 == 0) and epoch != 0:\n",
+    "            eval_probe(model, epoch + 1)\n",
+    "\n",
+    "# Main\n",
+    "def main(probe_type=\"linear\", epochs=10):\n",
+    "    train_loader, test_loader, num_classes = get_data_loaders()\n",
+    "    encoder = get_mae_encoder()\n",
+    "    feature_dim = encoder.num_features\n",
+    "\n",
+    "    if probe_type == \"linear\":\n",
+    "        model = LinearProbe(encoder, feature_dim, num_classes)\n",
+    "    else:\n",
+    "        model = MLPProbe(encoder, feature_dim, num_classes)\n",
+    "\n",
+    "    train_probe(model, train_loader, test_loader, num_epochs=epochs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "e636112e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/100, Loss: 4.6002\n",
+      "Epoch 2/100, Loss: 4.3484\n",
+      "Epoch 3/100, Loss: 4.1574\n",
+      "Epoch 4/100, Loss: 3.9755\n",
+      "Epoch 5/100, Loss: 3.8144\n",
+      "Epoch 6/100, Loss: 3.6604\n",
+      "Epoch 7/100, Loss: 3.5150\n",
+      "Epoch 8/100, Loss: 3.3813\n",
+      "Epoch 9/100, Loss: 3.2614\n",
+      "Epoch 10/100, Loss: 3.1425\n",
+      "\n",
+      "----------At epoch 10-------------\n",
+      "Test Accuracy: 55.70%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 11/100, Loss: 3.0350\n",
+      "Epoch 12/100, Loss: 2.9339\n",
+      "Epoch 13/100, Loss: 2.8374\n",
+      "Epoch 14/100, Loss: 2.7456\n",
+      "Epoch 15/100, Loss: 2.6621\n",
+      "Epoch 16/100, Loss: 2.5775\n",
+      "Epoch 17/100, Loss: 2.5010\n",
+      "Epoch 18/100, Loss: 2.4271\n",
+      "Epoch 19/100, Loss: 2.3574\n",
+      "Epoch 20/100, Loss: 2.2930\n",
+      "\n",
+      "----------At epoch 20-------------\n",
+      "Test Accuracy: 62.03%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 21/100, Loss: 2.2281\n",
+      "Epoch 22/100, Loss: 2.1697\n",
+      "Epoch 23/100, Loss: 2.1123\n",
+      "Epoch 24/100, Loss: 2.0592\n",
+      "Epoch 25/100, Loss: 2.0081\n",
+      "Epoch 26/100, Loss: 1.9559\n",
+      "Epoch 27/100, Loss: 1.9083\n",
+      "Epoch 28/100, Loss: 1.8653\n",
+      "Epoch 29/100, Loss: 1.8184\n",
+      "Epoch 30/100, Loss: 1.7731\n",
+      "\n",
+      "----------At epoch 30-------------\n",
+      "Test Accuracy: 64.90%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 31/100, Loss: 1.7384\n",
+      "Epoch 32/100, Loss: 1.7002\n",
+      "Epoch 33/100, Loss: 1.6622\n",
+      "Epoch 34/100, Loss: 1.6243\n",
+      "Epoch 35/100, Loss: 1.5935\n",
+      "Epoch 36/100, Loss: 1.5593\n",
+      "Epoch 37/100, Loss: 1.5256\n",
+      "Epoch 38/100, Loss: 1.4957\n",
+      "Epoch 39/100, Loss: 1.4648\n",
+      "Epoch 40/100, Loss: 1.4352\n",
+      "\n",
+      "----------At epoch 40-------------\n",
+      "Test Accuracy: 67.38%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 41/100, Loss: 1.4065\n",
+      "Epoch 42/100, Loss: 1.3806\n",
+      "Epoch 43/100, Loss: 1.3539\n",
+      "Epoch 44/100, Loss: 1.3288\n",
+      "Epoch 45/100, Loss: 1.3028\n",
+      "Epoch 46/100, Loss: 1.2798\n",
+      "Epoch 47/100, Loss: 1.2552\n",
+      "Epoch 48/100, Loss: 1.2339\n",
+      "Epoch 49/100, Loss: 1.2141\n",
+      "Epoch 50/100, Loss: 1.1919\n",
+      "\n",
+      "----------At epoch 50-------------\n",
+      "Test Accuracy: 69.49%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 51/100, Loss: 1.1701\n",
+      "Epoch 52/100, Loss: 1.1531\n",
+      "Epoch 53/100, Loss: 1.1330\n",
+      "Epoch 54/100, Loss: 1.1163\n",
+      "Epoch 55/100, Loss: 1.0969\n",
+      "Epoch 56/100, Loss: 1.0760\n",
+      "Epoch 57/100, Loss: 1.0610\n",
+      "Epoch 58/100, Loss: 1.0428\n",
+      "Epoch 59/100, Loss: 1.0282\n",
+      "Epoch 60/100, Loss: 1.0103\n",
+      "\n",
+      "----------At epoch 60-------------\n",
+      "Test Accuracy: 70.79%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 61/100, Loss: 0.9973\n",
+      "Epoch 62/100, Loss: 0.9801\n",
+      "Epoch 63/100, Loss: 0.9647\n",
+      "Epoch 64/100, Loss: 0.9515\n",
+      "Epoch 65/100, Loss: 0.9357\n",
+      "Epoch 66/100, Loss: 0.9230\n",
+      "Epoch 67/100, Loss: 0.9095\n",
+      "Epoch 68/100, Loss: 0.8958\n",
+      "Epoch 69/100, Loss: 0.8817\n",
+      "Epoch 70/100, Loss: 0.8691\n",
+      "\n",
+      "----------At epoch 70-------------\n",
+      "Test Accuracy: 71.93%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 71/100, Loss: 0.8563\n",
+      "Epoch 72/100, Loss: 0.8429\n",
+      "Epoch 73/100, Loss: 0.8328\n",
+      "Epoch 74/100, Loss: 0.8209\n",
+      "Epoch 75/100, Loss: 0.8094\n",
+      "Epoch 76/100, Loss: 0.7982\n",
+      "Epoch 77/100, Loss: 0.7883\n",
+      "Epoch 78/100, Loss: 0.7761\n",
+      "Epoch 79/100, Loss: 0.7655\n",
+      "Epoch 80/100, Loss: 0.7569\n",
+      "\n",
+      "----------At epoch 80-------------\n",
+      "Test Accuracy: 73.10%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 81/100, Loss: 0.7463\n",
+      "Epoch 82/100, Loss: 0.7351\n",
+      "Epoch 83/100, Loss: 0.7262\n",
+      "Epoch 84/100, Loss: 0.7154\n",
+      "Epoch 85/100, Loss: 0.7078\n",
+      "Epoch 86/100, Loss: 0.6977\n",
+      "Epoch 87/100, Loss: 0.6872\n",
+      "Epoch 88/100, Loss: 0.6793\n",
+      "Epoch 89/100, Loss: 0.6699\n",
+      "Epoch 90/100, Loss: 0.6623\n",
+      "\n",
+      "----------At epoch 90-------------\n",
+      "Test Accuracy: 73.98%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 91/100, Loss: 0.6521\n",
+      "Epoch 92/100, Loss: 0.6441\n",
+      "Epoch 93/100, Loss: 0.6363\n",
+      "Epoch 94/100, Loss: 0.6271\n",
+      "Epoch 95/100, Loss: 0.6207\n",
+      "Epoch 96/100, Loss: 0.6129\n",
+      "Epoch 97/100, Loss: 0.6059\n",
+      "Epoch 98/100, Loss: 0.5970\n",
+      "Epoch 99/100, Loss: 0.5902\n",
+      "Epoch 100/100, Loss: 0.5822\n",
+      "\n",
+      "----------At epoch 100-------------\n",
+      "Test Accuracy: 74.73%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "linear_model = main(\"linear\", 100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "7853f4d1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/100, Loss: 4.5673\n",
+      "Epoch 2/100, Loss: 4.1920\n",
+      "Epoch 3/100, Loss: 3.7355\n",
+      "Epoch 4/100, Loss: 3.3093\n",
+      "Epoch 5/100, Loss: 2.9592\n",
+      "Epoch 6/100, Loss: 2.6730\n",
+      "Epoch 7/100, Loss: 2.4268\n",
+      "Epoch 8/100, Loss: 2.2041\n",
+      "Epoch 9/100, Loss: 2.0328\n",
+      "Epoch 10/100, Loss: 1.8593\n",
+      "\n",
+      "----------At epoch 10-------------\n",
+      "Test Accuracy: 48.71%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 11/100, Loss: 1.7107\n",
+      "Epoch 12/100, Loss: 1.5753\n",
+      "Epoch 13/100, Loss: 1.4717\n",
+      "Epoch 14/100, Loss: 1.3765\n",
+      "Epoch 15/100, Loss: 1.2868\n",
+      "Epoch 16/100, Loss: 1.2018\n",
+      "Epoch 17/100, Loss: 1.1266\n",
+      "Epoch 18/100, Loss: 1.0640\n",
+      "Epoch 19/100, Loss: 0.9991\n",
+      "Epoch 20/100, Loss: 0.9440\n",
+      "\n",
+      "----------At epoch 20-------------\n",
+      "Test Accuracy: 62.48%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 21/100, Loss: 0.8962\n",
+      "Epoch 22/100, Loss: 0.8549\n",
+      "Epoch 23/100, Loss: 0.7974\n",
+      "Epoch 24/100, Loss: 0.7521\n",
+      "Epoch 25/100, Loss: 0.7150\n",
+      "Epoch 26/100, Loss: 0.6880\n",
+      "Epoch 27/100, Loss: 0.6544\n",
+      "Epoch 28/100, Loss: 0.6124\n",
+      "Epoch 29/100, Loss: 0.5915\n",
+      "Epoch 30/100, Loss: 0.5552\n",
+      "\n",
+      "----------At epoch 30-------------\n",
+      "Test Accuracy: 70.17%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 31/100, Loss: 0.5370\n",
+      "Epoch 32/100, Loss: 0.5043\n",
+      "Epoch 33/100, Loss: 0.4875\n",
+      "Epoch 34/100, Loss: 0.4619\n",
+      "Epoch 35/100, Loss: 0.4472\n",
+      "Epoch 36/100, Loss: 0.4203\n",
+      "Epoch 37/100, Loss: 0.4019\n",
+      "Epoch 38/100, Loss: 0.3815\n",
+      "Epoch 39/100, Loss: 0.3656\n",
+      "Epoch 40/100, Loss: 0.3553\n",
+      "\n",
+      "----------At epoch 40-------------\n",
+      "Test Accuracy: 72.29%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 41/100, Loss: 0.3338\n",
+      "Epoch 42/100, Loss: 0.3217\n",
+      "Epoch 43/100, Loss: 0.3035\n",
+      "Epoch 44/100, Loss: 0.2950\n",
+      "Epoch 45/100, Loss: 0.2787\n",
+      "Epoch 46/100, Loss: 0.2688\n",
+      "Epoch 47/100, Loss: 0.2496\n",
+      "Epoch 48/100, Loss: 0.2465\n",
+      "Epoch 49/100, Loss: 0.2346\n",
+      "Epoch 50/100, Loss: 0.2286\n",
+      "\n",
+      "----------At epoch 50-------------\n",
+      "Test Accuracy: 73.04%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 51/100, Loss: 0.2150\n",
+      "Epoch 52/100, Loss: 0.2044\n",
+      "Epoch 53/100, Loss: 0.2015\n",
+      "Epoch 54/100, Loss: 0.1872\n",
+      "Epoch 55/100, Loss: 0.1855\n",
+      "Epoch 56/100, Loss: 0.1686\n",
+      "Epoch 57/100, Loss: 0.1660\n",
+      "Epoch 58/100, Loss: 0.1537\n",
+      "Epoch 59/100, Loss: 0.1488\n",
+      "Epoch 60/100, Loss: 0.1406\n",
+      "\n",
+      "----------At epoch 60-------------\n",
+      "Test Accuracy: 73.56%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 61/100, Loss: 0.1325\n",
+      "Epoch 62/100, Loss: 0.1289\n",
+      "Epoch 63/100, Loss: 0.1221\n",
+      "Epoch 64/100, Loss: 0.1178\n",
+      "Epoch 65/100, Loss: 0.1119\n",
+      "Epoch 66/100, Loss: 0.1103\n",
+      "Epoch 67/100, Loss: 0.1052\n",
+      "Epoch 68/100, Loss: 0.1024\n",
+      "Epoch 69/100, Loss: 0.0954\n",
+      "Epoch 70/100, Loss: 0.0929\n",
+      "\n",
+      "----------At epoch 70-------------\n",
+      "Test Accuracy: 74.60%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 71/100, Loss: 0.0887\n",
+      "Epoch 72/100, Loss: 0.0823\n",
+      "Epoch 73/100, Loss: 0.0791\n",
+      "Epoch 74/100, Loss: 0.0773\n",
+      "Epoch 75/100, Loss: 0.0759\n",
+      "Epoch 76/100, Loss: 0.0702\n",
+      "Epoch 77/100, Loss: 0.0689\n",
+      "Epoch 78/100, Loss: 0.0665\n",
+      "Epoch 79/100, Loss: 0.0639\n",
+      "Epoch 80/100, Loss: 0.0614\n",
+      "\n",
+      "----------At epoch 80-------------\n",
+      "Test Accuracy: 74.55%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 81/100, Loss: 0.0577\n",
+      "Epoch 82/100, Loss: 0.0560\n",
+      "Epoch 83/100, Loss: 0.0540\n",
+      "Epoch 84/100, Loss: 0.0519\n",
+      "Epoch 85/100, Loss: 0.0498\n",
+      "Epoch 86/100, Loss: 0.0494\n",
+      "Epoch 87/100, Loss: 0.0468\n",
+      "Epoch 88/100, Loss: 0.0458\n",
+      "Epoch 89/100, Loss: 0.0415\n",
+      "Epoch 90/100, Loss: 0.0401\n",
+      "\n",
+      "----------At epoch 90-------------\n",
+      "Test Accuracy: 75.23%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n",
+      "Epoch 91/100, Loss: 0.0398\n",
+      "Epoch 92/100, Loss: 0.0389\n",
+      "Epoch 93/100, Loss: 0.0360\n",
+      "Epoch 94/100, Loss: 0.0351\n",
+      "Epoch 95/100, Loss: 0.0337\n",
+      "Epoch 96/100, Loss: 0.0329\n",
+      "Epoch 97/100, Loss: 0.0322\n",
+      "Epoch 98/100, Loss: 0.0308\n",
+      "Epoch 99/100, Loss: 0.0301\n",
+      "Epoch 100/100, Loss: 0.0282\n",
+      "\n",
+      "----------At epoch 100-------------\n",
+      "Test Accuracy: 75.43%\n",
+      "\n",
+      "------------------------------------------\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "mlp_model = main(\"mlp\", 100)"
+   ]
+  }
+ ],
+ "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.8.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}