Image Classification Pytorch.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "1b1da87d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1/10], Train Loss: 0.6575, Train Accuracy: 0.5250, Val Loss: 0.3224, Val Accuracy: 1.0000\n",
      "Epoch [2/10], Train Loss: 0.3054, Train Accuracy: 0.9125, Val Loss: 0.1285, Val Accuracy: 0.9000\n",
      "Epoch [3/10], Train Loss: 0.1894, Train Accuracy: 0.9625, Val Loss: 0.0575, Val Accuracy: 1.0000\n",
      "Epoch [4/10], Train Loss: 0.1658, Train Accuracy: 0.8875, Val Loss: 0.0299, Val Accuracy: 1.0000\n",
      "Epoch [5/10], Train Loss: 0.1631, Train Accuracy: 0.9125, Val Loss: 0.0536, Val Accuracy: 1.0000\n",
      "Epoch [6/10], Train Loss: 0.0555, Train Accuracy: 0.9875, Val Loss: 0.0241, Val Accuracy: 1.0000\n",
      "Epoch [7/10], Train Loss: 0.0477, Train Accuracy: 1.0000, Val Loss: 0.0459, Val Accuracy: 1.0000\n",
      "Epoch [8/10], Train Loss: 0.0152, Train Accuracy: 1.0000, Val Loss: 0.0085, Val Accuracy: 1.0000\n",
      "Epoch [9/10], Train Loss: 0.0076, Train Accuracy: 1.0000, Val Loss: 0.0050, Val Accuracy: 1.0000\n",
      "Epoch [10/10], Train Loss: 0.0048, Train Accuracy: 1.0000, Val Loss: 0.0061, Val Accuracy: 1.0000\n",
      "Predicted Label: rama\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torchvision import datasets, transforms\n",
    "from torch.utils.data import DataLoader\n",
    "from PIL import Image\n",
    "\n",
    "# Step 1: Data Preparation\n",
    "data_transforms = transforms.Compose([\n",
    "    transforms.Resize((224, 224)),  # Resize the images to a fixed size\n",
    "    transforms.ToTensor(),  # Convert images to tensors\n",
    "    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # Normalize the images\n",
    "])\n",
    "\n",
    "train_dataset = datasets.ImageFolder(r'C:\\Users\\sskir\\Desktop\\3rdsem\\workshop\\data\\train', transform=data_transforms)\n",
    "val_dataset = datasets.ImageFolder(r'C:\\Users\\sskir\\Desktop\\3rdsem\\workshop\\data\\valid', transform=data_transforms)\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n",
    "val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)\n",
    "\n",
    "# Step 2: Define the Network\n",
    "class MyNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(MyNet, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1)\n",
    "        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        self.fc1 = nn.Linear(16 * 112 * 112, 64)\n",
    "        self.fc2 = nn.Linear(64, 2)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.pool(torch.relu(self.conv1(x)))\n",
    "        x = x.view(-1, 16 * 112 * 112)\n",
    "        x = torch.relu(self.fc1(x))\n",
    "        x = self.fc2(x)\n",
    "        return x\n",
    "\n",
    "model = MyNet()\n",
    "\n",
    "# Step 3: Define the Loss Function\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "# Step 4: Define the Optimization Algorithm\n",
    "optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# Step 5: Training Loop\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "model.to(device)\n",
    "\n",
    "num_epochs = 10\n",
    "for epoch in range(num_epochs):\n",
    "    model.train()\n",
    "    running_loss = 0.0\n",
    "    correct = 0\n",
    "    total = 0\n",
    "\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 = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        running_loss += loss.item()\n",
    "        _, predicted = torch.max(outputs, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "\n",
    "    train_loss = running_loss / len(train_loader)\n",
    "    train_accuracy = correct / total\n",
    "\n",
    "    # Validation\n",
    "    model.eval()\n",
    "    val_loss = 0.0\n",
    "    val_correct = 0\n",
    "    val_total = 0\n",
    "\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",
    "            loss = criterion(outputs, labels)\n",
    "\n",
    "            val_loss += loss.item()\n",
    "            _, predicted = torch.max(outputs, 1)\n",
    "            val_total += labels.size(0)\n",
    "            val_correct += (predicted == labels).sum().item()\n",
    "\n",
    "    val_loss = val_loss / len(val_loader)\n",
    "    val_accuracy = val_correct / val_total\n",
    "\n",
    "    print(f\"Epoch [{epoch+1}/{num_epochs}], \"\n",
    "          f\"Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy:.4f}, \"\n",
    "          f\"Val Loss: {val_loss:.4f}, Val Accuracy: {val_accuracy:.4f}\")\n",
    "\n",
    "# Step 6: Evaluate the Model\n",
    "# You can test the model on a separate test set using a similar validation loop.\n",
    "\n",
    "# Step 7: Save and Load the Model\n",
    "torch.save(model.state_dict(), r'C:\\Users\\sskir\\Desktop\\3rdsem\\workshop\\model.pt')\n",
    "# To load the model later:\n",
    "# model = MyNet()\n",
    "# model.load_state_dict(torch.load('path/to/save/model.pt'))\n",
    "\n",
    "# Classify User-provided Images\n",
    "model.eval()\n",
    "\n",
    "# Load the saved model\n",
    "model.load_state_dict(torch.load(r'C:\\Users\\sskir\\Desktop\\3rdsem\\workshop\\model.pt'))\n",
    "model.to(device)\n",
    "\n",
    "# Load and preprocess the user-provided image\n",
    "user_image_path = r'C:\\Users\\sskir\\Desktop\\3rdsem\\workshop\\data\\test\\rama\\rama (46).jpg'  # Replace with the path to the user's image\n",
    "user_image = Image.open(user_image_path)\n",
    "user_image = data_transforms(user_image).unsqueeze(0).to(device)\n",
    "\n",
    "# Perform inference\n",
    "with torch.no_grad():\n",
    "    output = model(user_image)\n",
    "    _, predicted = torch.max(output, 1)\n",
    "\n",
    "# Get the predicted class label\n",
    "predicted_label = train_dataset.classes[predicted.item()]\n",
    "print(\"Predicted Label:\", predicted_label)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}