Upload 3 files

CNNModel.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:743c5bd5649673a5fbe1a54c3461a887b0f58a9a2b4087dd447d349629335718
+size 24202490

a6_main.ipynb

@@ -0,0 +1,279 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "db12ed37",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import time\n",
+    "import random\n",
+    "import numpy as np\n",
+    "import torch as tr\n",
+    "import torchvision as tv\n",
+    "import os"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "17b5ddc1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Current working directory: C:\\Users\\upm\\Untitled Folder\n"
+     ]
+    }
+   ],
+   "source": [
+    "os.chdir(r\"C:\\Users\\upm\\Untitled Folder\")\n",
+    "print(\"Current working directory:\", os.getcwd())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "6f25f03e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "TinyImageNet dataset already exists.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import urllib.request\n",
+    "import zipfile\n",
+    "\n",
+    "# Define the URL to the TinyImageNet dataset\n",
+    "dataset_url = 'http://cs231n.stanford.edu/tiny-imagenet-200.zip'\n",
+    "dataset_dir = 'tiny-imagenet-200'\n",
+    "\n",
+    "# Check if the dataset directory already exists, if not, download the dataset\n",
+    "if not os.path.exists(dataset_dir):\n",
+    "    print(\"Downloading TinyImageNet...\")\n",
+    "    # Download the dataset\n",
+    "    urllib.request.urlretrieve(dataset_url, 'tiny-imagenet-200.zip')\n",
+    "    \n",
+    "    # Extract the dataset\n",
+    "    with zipfile.ZipFile('tiny-imagenet-200.zip', 'r') as zip_ref:\n",
+    "        zip_ref.extractall()\n",
+    "    \n",
+    "    print(\"TinyImageNet dataset downloaded and extracted.\")\n",
+    "else:\n",
+    "    print(\"TinyImageNet dataset already exists.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "b4dff407",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from torchvision import datasets, transforms\n",
+    "from torch.utils.data import DataLoader\n",
+    "\n",
+    "dataset_dir = r'C:\\Users\\upm\\Untitled Folder\\tiny-imagenet-200'\n",
+    "\n",
+    "transform = transforms.Compose([\n",
+    "    transforms.Resize(64),\n",
+    "    transforms.ToTensor(),\n",
+    "    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n",
+    "])\n",
+    "\n",
+    "# Load the training and validation datasets\n",
+    "train_data = datasets.ImageFolder(root=os.path.join(dataset_dir, 'train'), transform=transform)\n",
+    "\n",
+    "val_data = datasets.ImageFolder(root=os.path.join(dataset_dir, 'val'), transform=transform)\n",
+    "\n",
+    "train_loader = DataLoader(train_data, batch_size=128, shuffle=True)\n",
+    "val_loader = DataLoader(val_data, batch_size=128, shuffle=False)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "72b665d0",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "39b0b177",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1: Train Acc: 0.4% - Val Acc: 0.0% - Loss: 5.3022\n",
+      "Epoch 2: Train Acc: 0.5% - Val Acc: 0.0% - Loss: 5.3020\n",
+      "Epoch 3: Train Acc: 0.4% - Val Acc: 0.0% - Loss: 5.3023\n",
+      "Epoch 4: Train Acc: 0.5% - Val Acc: 0.0% - Loss: 5.3001\n",
+      "Epoch 5: Train Acc: 0.5% - Val Acc: 0.0% - Loss: 5.2992\n",
+      "Epoch 6: Train Acc: 0.4% - Val Acc: 0.0% - Loss: 5.2990\n",
+      "Epoch 7: Train Acc: 0.5% - Val Acc: 0.0% - Loss: 5.2984\n",
+      "Epoch 8: Train Acc: 0.5% - Val Acc: 0.0% - Loss: 5.2984\n",
+      "Epoch 9: Train Acc: 0.5% - Val Acc: 0.0% - Loss: 5.2984\n",
+      "Epoch 10: Train Acc: 0.5% - Val Acc: 0.0% - Loss: 5.2984\n",
+      "Training Complete in 11.52 minutes\n"
+     ]
+    }
+   ],
+   "source": [
+    "import import_ipynb\n",
+    "from a6_model_Sana import CNNModel\n",
+    "import torch\n",
+    "import torch.optim as optim\n",
+    "import torch.nn as nn\n",
+    "from torch.utils.data import DataLoader\n",
+    "import time\n",
+    "\n",
+    "loss_func = nn.CrossEntropyLoss()\n",
+    "\n",
+    "optimizer = optim.Adam(model.parameters(), lr=0.01)\n",
+    "\n",
+    "\n",
+    "scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=3, gamma=0.1)\n",
+    "\n",
+    "\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "model.to(device)\n",
+    "\n",
+    "num_epochs = 10  # Train for 10 epochs\n",
+    "train_losses, val_accuracies = [], []\n",
+    "\n",
+    "start_time = time.time()\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    model.train()\n",
+    "    running_loss = 0.0\n",
+    "    correct, total = 0, 0\n",
+    "    for images, labels in train_loader:\n",
+    "        images, labels = images.to(device), labels.to(device)\n",
+    "\n",
+    "        optimizer.zero_grad()\n",
+    "        outputs = model(images)\n",
+    "        loss = loss_func(outputs, labels)\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "\n",
+    "        running_loss += loss.item()\n",
+    "        _, predicted = torch.max(outputs.data, 1)\n",
+    "        total += labels.size(0)\n",
+    "        correct += (predicted == labels).sum().item()\n",
+    "    scheduler.step()\n",
+    "    \n",
+    "    train_accuracy = 100 * correct / total\n",
+    "    train_losses.append(running_loss / len(train_loader))\n",
+    "    \n",
+    "    model.eval()\n",
+    "    correct, total = 0, 0\n",
+    "    with torch.no_grad():\n",
+    "        for images, labels in val_loader:\n",
+    "            images, labels = images.to(device), labels.to(device)\n",
+    "            outputs = model(images)\n",
+    "            _, predicted = torch.max(outputs.data, 1)\n",
+    "            total += labels.size(0)\n",
+    "            correct += (predicted == labels).sum().item()\n",
+    "    \n",
+    "    val_accuracy = 100 * correct / total\n",
+    "    val_accuracies.append(val_accuracy)\n",
+    "    epoch_loss = running_loss / len(train_loader)\n",
+    "    \n",
+    "    print(f\"Epoch {epoch+1}: Train Acc: {train_accuracy:.1f}% - Val Acc: {val_accuracy:.1f}% - Loss: {epoch_loss:.4f}\")\n",
+    "\n",
+    "end_time = time.time()\n",
+    "print(f\"Training Complete in {((end_time - start_time)/60):.2f} minutes\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "b9cdd9bb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "torch.save(model.state_dict(), \"CNNModel.pth\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "id": "e0436de2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Training Summary:\n",
+      "Reaching Training Accuracy: 0.4%\n",
+      "Reaching Validation Accuracy: 0.0%\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"\\nTraining Summary:\")\n",
+    "print(f\"Reaching Training Accuracy: {train_accuracy:.1f}%\")\n",
+    "print(f\"Reaching Validation Accuracy: {val_accuracy:.1f}%\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "id": "eb1e698f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "GPU: NVIDIA GeForce RTX 3060 with 12.0 GB RAM\n"
+     ]
+    }
+   ],
+   "source": [
+    "if torch.cuda.is_available():\n",
+    "    gpu_name = torch.cuda.get_device_name(0)\n",
+    "    total_memory = torch.cuda.get_device_properties(0).total_memory / (1024**3)  # Convert bytes to GB\n",
+    "    print(f\"GPU: {gpu_name} with {total_memory:.1f} GB RAM\")\n",
+    "else:\n",
+    "    print(\"No GPU detected.\")\n"
+   ]
+  }
+ ],
+ "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

a6_model_Sana.ipynb

@@ -0,0 +1,197 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "17d453bb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Current working directory: C:\\Users\\upm\\Untitled Folder\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "print(\"Current working directory:\", os.getcwd())\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "abd68c23",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CNNModel(\n",
+      "  (conv1): Conv2d(3, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
+      "  (conv2): Conv2d(64, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
+      "  (conv3): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "  (conv4): Conv2d(256, 384, kernel_size=(5, 5), stride=(1, 1), padding=(1, 1))\n",
+      "  (conv5): Conv2d(384, 256, kernel_size=(1, 1), stride=(1, 1), padding=(1, 1))\n",
+      "  (adaptive_pool): AdaptiveAvgPool2d(output_size=(3, 3))\n",
+      "  (fc1): Linear(in_features=2304, out_features=1024, bias=True)\n",
+      "  (fc2): Linear(in_features=1024, out_features=512, bias=True)\n",
+      "  (fc3): Linear(in_features=512, out_features=200, bias=True)\n",
+      "  (dropout): Dropout(p=0.1, inplace=False)\n",
+      ")\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch as tr\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "\n",
+    "class CNNModel(tr.nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(CNNModel, self).__init__()\n",
+    "\n",
+    "        # Conv Layer 1: 64 channels, 5x5 kernel, padding=2\n",
+    "        self.conv1 = nn.Conv2d(3, 64, kernel_size=5, padding=2,stride=1)\n",
+    "        # Conv Layer 2: 128 channels, 5x5 kernel, padding=2\n",
+    "        self.conv2 = nn.Conv2d(64, 128, kernel_size=5, padding=2)\n",
+    "        # Conv Layer 3: 256 channels, 3x3 kernel, padding=1\n",
+    "        self.conv3 = nn.Conv2d(128, 256, kernel_size=3, padding=1)\n",
+    "        # Conv Layer 4: 384 channels, 5x5 kernel, padding=1\n",
+    "        self.conv4 = nn.Conv2d(256, 384, kernel_size=5, padding=1)\n",
+    "        # Conv Layer 5: 256 channels, 1x1 kernel, padding=1\n",
+    "        self.conv5 = nn.Conv2d(384, 256, kernel_size=1, padding=1)\n",
+    "\n",
+    "        # Adaptive Average Pooling Layer\n",
+    "        self.adaptive_pool = nn.AdaptiveAvgPool2d((3, 3))\n",
+    "\n",
+    "        # Fully Connected Layers\n",
+    "        self.fc1 = nn.Linear(256 * 3 * 3, 1024)\n",
+    "        self.fc2 = nn.Linear(1024, 512)\n",
+    "        self.fc3 = nn.Linear(512, 200)\n",
+    "\n",
+    "        # Dropout Layers\n",
+    "        self.dropout = nn.Dropout(p=0.1)\n",
+    "\n",
+    "    def init_weights(self):\n",
+    "        tr.nn.init.normal_(self.linear1.weight, mean=0.0, std=0.01)\n",
+    "        tr.nn.init.normal_(self.linear2.weight, mean=0.0, std=0.01)\n",
+    "        tr.nn.init.normal_(self.linear3.weight, mean=0.0, std=0.01)\n",
+    "        \n",
+    "    def init_weights(self):\n",
+    "        # Initialize weights with normal distribution and biases with ones\n",
+    "        tr.nn.init.normal_(self.conv1.weight, mean=0.0, std=0.01)\n",
+    "        tr.nn.init.normal_(self.conv2.weight, mean=0.0, std=0.01)\n",
+    "        tr.nn.init.normal_(self.conv3.weight, mean=0.0, std=0.01)\n",
+    "        tr.nn.init.normal_(self.conv4.weight, mean=0.0, std=0.01)\n",
+    "        tr.nn.init.normal_(self.conv5.weight, mean=0.0, std=0.01)\n",
+    "        tr.nn.init.ones_(self.conv1.bias)\n",
+    "        tr.nn.init.ones_(self.conv2.bias)\n",
+    "        tr.nn.init.ones_(self.conv3.bias)\n",
+    "        tr.nn.init.ones_(self.conv4.bias)\n",
+    "        tr.nn.init.ones_(self.conv5.bias)\n",
+    "        tr.nn.init.normal_(self.fc1.weight, mean=0.0, std=0.01)\n",
+    "        tr.nn.init.normal_(self.fc2.weight, mean=0.0, std=0.01)\n",
+    "        tr.nn.init.normal_(self.fc3.weight, mean=0.0, std=0.01)\n",
+    "        tr.nn.init.ones_(self.fc1.bias)\n",
+    "        tr.nn.init.ones_(self.fc2.bias)\n",
+    "        tr.nn.init.ones_(self.fc3.bias)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        # Apply Conv Layer 1, ReLU, and Max Pooling\n",
+    "        x = self.conv1(x)\n",
+    "        x = F.relu(x)\n",
+    "        x = F.max_pool2d(x, kernel_size=2, stride=2)\n",
+    "\n",
+    "        # Apply Conv Layer 2, ReLU, and Max Pooling\n",
+    "        x = self.conv2(x)\n",
+    "        x = F.relu(x)\n",
+    "        x = F.max_pool2d(x, kernel_size=2, stride=2)\n",
+    "\n",
+    "        # Apply Conv Layer 3, ReLU, and Max Pooling\n",
+    "        x = self.conv3(x)\n",
+    "        x = F.relu(x)\n",
+    "        x = F.max_pool2d(x, kernel_size=2, stride=2)\n",
+    "\n",
+    "        # Apply Conv Layer 4 and ReLU\n",
+    "        x = self.conv4(x)\n",
+    "        x = F.relu(x)\n",
+    "\n",
+    "        # Apply Conv Layer 5 and ReLU\n",
+    "        x = self.conv5(x)\n",
+    "        x = F.relu(x)\n",
+    "\n",
+    "        # Apply Adaptive Average Pooling\n",
+    "        x = self.adaptive_pool(x)\n",
+    "\n",
+    "        # Flatten the output\n",
+    "        x = x.flatten(1)\n",
+    "\n",
+    "        # Fully connected layer 1 and dropout\n",
+    "        x = self.dropout(x)\n",
+    "        x = self.fc1(x)\n",
+    "        x = F.relu(x)\n",
+    "        \n",
+    "\n",
+    "        # Fully connected layer 2 and dropout\n",
+    "        x = self.dropout(x)\n",
+    "        x = self.fc2(x)\n",
+    "        x = F.relu(x)\n",
+    "        \n",
+    "\n",
+    "        # Fully connected layer 3 \n",
+    "        x = self.fc3(x)\n",
+    "        \n",
+    "        return x\n",
+    "\n",
+    "# Instantiate the model\n",
+    "model = CNNModel()\n",
+    "\n",
+    "# Initialize weights\n",
+    "model.init_weights()\n",
+    "\n",
+    "# Print the model summary (for verification)\n",
+    "print(model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "047a914d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "18cfbd55",
+   "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}