Upload 13 files

.gitattributes

@@ -33,3 +33,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data/cifar-10-batches-py/data_batch_1 filter=lfs diff=lfs merge=lfs -text
+data/cifar-10-batches-py/data_batch_2 filter=lfs diff=lfs merge=lfs -text
+data/cifar-10-batches-py/data_batch_3 filter=lfs diff=lfs merge=lfs -text
+data/cifar-10-batches-py/data_batch_4 filter=lfs diff=lfs merge=lfs -text
+data/cifar-10-batches-py/data_batch_5 filter=lfs diff=lfs merge=lfs -text
+data/cifar-10-batches-py/test_batch filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,169 @@
+import streamlit as st
+import torch
+import torch.nn as nn
+import torchvision.transforms as transforms
+from PIL import Image
+import torch.nn.functional as F
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+
+# ----------------- CLASS LABELS -----------------
+CLASSES = [
+    "airplane", "automobile", "bird", "cat", "deer",
+    "dog", "frog", "horse", "ship", "truck"
+]
+
+# ----------------- CNN MODEL (same as training) -----------------
+class CNN(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.conv_layer = nn.Sequential(
+            nn.Conv2d(3, 32, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(2, 2),
+
+            nn.Conv2d(32, 64, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(2, 2)
+        )
+
+        self.fc_layer = nn.Sequential(
+            nn.Linear(64 * 8 * 8, 256),
+            nn.ReLU(),
+            nn.Linear(256, 10)
+        )
+
+    def forward(self, x):
+        x = self.conv_layer(x)
+        x = x.view(x.size(0), -1)
+        x = self.fc_layer(x)
+        return x
+
+# ----------------- LOAD TRAINED MODEL -----------------
+model = CNN()
+import os
+MODEL_PATH = os.path.join(os.getcwd(), "model.pth")
+model.load_state_dict(torch.load(MODEL_PATH, map_location=torch.device('cpu')))
+
+model.eval()
+
+# ----------------- IMAGE TRANSFORMS -----------------
+transform = transforms.Compose([
+    transforms.Resize((32, 32)),
+    transforms.ToTensor(),
+    transforms.Normalize((0.5,), (0.5,))
+])
+# ----------------- GRAD CAM UTILS -----------------
+
+# ----------------- CORRECT GRAD-CAM IMPLEMENTATION -----------------
+
+# Store activations + gradients
+activations = None
+gradients = None
+
+# Save forward activations
+def save_activation(module, input, output):
+    global activations
+    activations = output
+
+# Save backward gradients
+def save_gradient(module, grad_input, grad_output):
+    global gradients
+    gradients = grad_output[0]
+
+
+def generate_gradcam(model, image_tensor):
+    global activations, gradients
+
+    # Last conv layer
+    last_conv_layer = model.conv_layer[3]  # Conv2d(32 → 64)
+
+    # Hook for forward activations
+    forward_handle = last_conv_layer.register_forward_hook(save_activation)
+
+    # Hook for backward gradients
+    backward_handle = last_conv_layer.register_backward_hook(save_gradient)
+
+    # Forward pass
+    output = model(image_tensor)
+    pred_class = output.argmax(dim=1)
+
+    # Backward pass
+    model.zero_grad()
+    output[0, pred_class].backward()
+
+    # Remove hooks
+    forward_handle.remove()
+    backward_handle.remove()
+
+    # Process gradients + activations
+    pooled_grads = torch.mean(gradients, dim=[0, 2, 3])
+    activation_maps = activations[0]
+
+    # Weight channels
+    for i in range(len(pooled_grads)):
+        activation_maps[i, :, :] *= pooled_grads[i]
+
+    heatmap = torch.mean(activation_maps, dim=0).detach().cpu().numpy()
+
+    # Normalize
+    heatmap = np.maximum(heatmap, 0)
+    heatmap = heatmap / np.max(heatmap)
+
+    return heatmap
+
+def overlay_heatmap(img, heatmap):
+    heatmap = np.uint8(255 * heatmap)
+    heatmap = Image.fromarray(heatmap).resize(img.size, Image.BILINEAR)
+    heatmap = np.array(heatmap)
+
+    # Colorize heatmap
+    heatmap_color = plt.cm.jet(heatmap)[:, :, :3] * 255
+    heatmap_color = heatmap_color.astype(np.uint8)
+
+    # Overlay with original
+    img_np = np.array(img)
+    superimposed = (0.6 * heatmap_color + 0.4 * img_np).astype(np.uint8)
+
+    return Image.fromarray(superimposed)
+
+# ----------------- STREAMLIT UI -----------------
+st.title("🖼️ CIFAR-10 Image Classifier (CNN)")
+
+uploaded_image = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png"])
+
+if uploaded_image:
+    image = Image.open(uploaded_image).convert("RGB")
+    st.image(image, caption="Uploaded Image", width=250)
+
+    img_tensor = transform(image).unsqueeze(0)
+
+    with torch.no_grad():
+        outputs = model(img_tensor)
+
+    # Apply softmax to get probabilities
+    probs = F.softmax(outputs, dim=1)[0]
+
+    # Get top-3 predictions
+    top3_prob, top3_idx = torch.topk(probs, 3)
+
+    st.write("### 🔍 Top Predictions:")
+    for i in range(3):
+        st.write(f"**{CLASSES[top3_idx[i]]}: {top3_prob[i].item()*100:.2f}%**")
+
+    # ----------------- BAR CHART -----------------
+    st.write("### 📊 Probability Distribution")
+
+    fig, ax = plt.subplots()
+    ax.bar(CLASSES, probs.tolist())
+    plt.xticks(rotation=45)
+    st.pyplot(fig)
+    # ----------------- GENERATE GRAD-CAM -----------------
+    heatmap = generate_gradcam(model, img_tensor)
+    cam_image = overlay_heatmap(image, heatmap)
+
+    st.write("### 🔥 Grad-CAM Heatmap")
+    st.image(cam_image, caption="Where the model is looking", use_column_width=True)
+
+

data/cifar-10-batches-py/data_batch_1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:54636561a3ce25bd3e19253c6b0d8538147b0ae398331ac4a2d86c6d987368cd
+size 31035704

data/cifar-10-batches-py/data_batch_2

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:766b2cef9fbc745cf056b3152224f7cf77163b330ea9a15f9392beb8b89bc5a8
+size 31035320

data/cifar-10-batches-py/data_batch_3

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

data/cifar-10-batches-py/data_batch_4

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

data/cifar-10-batches-py/data_batch_5

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

data/cifar-10-batches-py/readme.html

@@ -0,0 +1 @@
+<meta HTTP-EQUIV="REFRESH" content="0; url=http://www.cs.toronto.edu/~kriz/cifar.html">

data/cifar-10-batches-py/test_batch

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

data/cifar-10-python.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d958be074577803d12ecdefd02955f39262c83c16fe9348329d7fe0b5c001ce
+size 170498071

model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:20372faa89ed838d94fddbb2c548b87504e87c8f663542656585bb11b1367736
+size 4286056

requirements.txt

@@ -0,0 +1,6 @@
+streamlit
+torch
+torchvision
+pillow
+matplotlib
+numpy

train.py

@@ -0,0 +1,79 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torchvision
+import torchvision.transforms as transforms
+
+
+# ----------------- TRANSFORMS -----------------
+transform = transforms.Compose([
+    transforms.ToTensor(),
+    transforms.Normalize((0.5,), (0.5,))
+])
+
+
+# ----------------- LOAD DATASET -----------------
+train_set = torchvision.datasets.CIFAR10(
+    root="./data", train=True, download=True, transform=transform
+)
+
+test_set = torchvision.datasets.CIFAR10(
+    root="./data", train=False, download=True, transform=transform
+)
+
+train_loader = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True)
+test_loader = torch.utils.data.DataLoader(test_set, batch_size=64, shuffle=False)
+
+
+# ----------------- BUILD CNN MODEL -----------------
+class CNN(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.conv_layer = nn.Sequential(
+            nn.Conv2d(3, 32, kernel_size=3, padding=1),  
+            nn.ReLU(),
+            nn.MaxPool2d(2, 2),
+
+            nn.Conv2d(32, 64, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(2, 2)
+        )
+
+        self.fc_layer = nn.Sequential(
+            nn.Linear(64 * 8 * 8, 256),
+            nn.ReLU(),
+            nn.Linear(256, 10)
+        )
+
+    def forward(self, x):
+        x = self.conv_layer(x)
+        x = x.view(x.size(0), -1)
+        x = self.fc_layer(x)
+        return x
+
+
+model = CNN()
+
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.Adam(model.parameters(), lr=0.001)
+
+
+# ----------------- TRAIN LOOP -----------------
+for epoch in range(5):
+    running_loss = 0.0
+    for images, labels in train_loader:
+        optimizer.zero_grad()
+
+        outputs = model(images)
+        loss = criterion(outputs, labels)
+        loss.backward()
+        optimizer.step()
+
+        running_loss += loss.item()
+
+    print(f"Epoch {epoch+1}, Loss: {running_loss/len(train_loader)}")
+
+
+# ----------------- SAVE MODEL -----------------
+torch.save(model.state_dict(), "model.pth")
+print("Model saved as model.pth")