Upload 11 files

.gitignore

@@ -0,0 +1,4 @@
+/data/
+/models/model.pth
+kaggle.json
+*.zip

app.py

@@ -0,0 +1,38 @@
+import streamlit as st
+from PIL import Image
+import torch
+from torchvision import transforms
+from models.cnn import CNNModel
+from utils.transforms import get_transforms
+
+@st.cache_resource
+def load_model(model_path='saved_models/cnn_model.pth'):
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    checkpoint = torch.load(model_path, map_location=device)
+    class_names = checkpoint['class_names']
+    model = CNNModel(num_classes=len(class_names))
+    model.load_state_dict(checkpoint['model_state_dict'])
+    model.to(device)
+    model.eval()
+    return model, class_names, device
+
+st.title("📸 Intel Image Classification")
+st.write("Upload an image to classify it into one of the image categories: buildings, forest, glacier, mountain, sea, or street.")
+
+model, class_names, device = load_model()
+
+uploaded_file = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png"])
+
+if uploaded_file:
+    image = Image.open(uploaded_file).convert("RGB")
+    st.image(image, caption="Uploaded Image", use_container_width=True)
+
+    transform = get_transforms(train=False)
+    image_tensor = transform(image).unsqueeze(0).to(device)
+
+    with torch.no_grad():
+        output = model(image_tensor)
+        predicted_idx = torch.argmax(output, 1).item()
+        predicted_class = class_names[predicted_idx]
+
+    st.success(f"Predicted class: {predicted_class}")

models/cnn.py

@@ -0,0 +1,19 @@
+import torch.nn as nn
+import torch.nn.functional as F
+
+class CNNModel(nn.Module):
+    def __init__(self, num_classes):
+        super(CNNModel, self).__init__()
+        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
+        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
+        self.pool = nn.MaxPool2d(2, 2)
+        self.fc1 = nn.Linear(64 * 37 * 37, 128)
+        self.fc2 = nn.Linear(128, num_classes)
+
+    def forward(self, x):
+        x = self.pool(F.relu(self.conv1(x)))  # 150->75
+        x = self.pool(F.relu(self.conv2(x)))  # 75->37
+        x = x.view(-1, 64 * 37 * 37)
+        x = F.relu(self.fc1(x))
+        x = self.fc2(x)
+        return x

requirements.txt

@@ -1,3 +1,5 @@
-altair
-pandas
-streamlit
+torch
+torchvision
+streamlit
+Pillow
+kaggle

saved_models/cnn_model.pth

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

train.py

@@ -0,0 +1,77 @@
+import os
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader, random_split
+from torchvision.datasets import ImageFolder
+from torchvision import transforms
+from models.cnn import CNNModel
+from utils.transforms import get_transforms
+
+def train_model(data_dir='data/intel/seg_train', epochs=10, batch_size=32, save_path='saved_models/cnn_model.pth'):
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    # Load dataset with ImageFolder (expects folder structure: class subfolders)
+    full_dataset = ImageFolder(root=data_dir, transform=get_transforms(train=True))
+    class_names = full_dataset.classes
+    print(f"Classes: {class_names}")
+
+    # Split dataset 80% train, 20% val
+    train_size = int(0.8 * len(full_dataset))
+    val_size = len(full_dataset) - train_size
+    train_ds, val_ds = random_split(full_dataset, [train_size, val_size])
+
+    # Update val transforms (no augmentation)
+    val_ds.dataset.transform = get_transforms(train=False)
+
+    train_loader = DataLoader(train_ds, batch_size=batch_size, shuffle=True)
+    val_loader = DataLoader(val_ds, batch_size=batch_size)
+
+    model = CNNModel(num_classes=len(class_names)).to(device)
+    criterion = nn.CrossEntropyLoss()
+    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
+
+    for epoch in range(epochs):
+        model.train()
+        total_loss = 0
+        total_correct = 0
+
+        for images, labels in train_loader:
+            images, labels = images.to(device), labels.to(device)
+            optimizer.zero_grad()
+            outputs = model(images)
+            loss = criterion(outputs, labels)
+            loss.backward()
+            optimizer.step()
+
+            total_loss += loss.item() * images.size(0)
+            total_correct += (outputs.argmax(1) == labels).sum().item()
+
+        train_loss = total_loss / len(train_loader.dataset)
+        train_acc = total_correct / len(train_loader.dataset)
+
+        # Validation
+        model.eval()
+        val_loss = 0
+        val_correct = 0
+        with torch.no_grad():
+            for images, labels in val_loader:
+                images, labels = images.to(device), labels.to(device)
+                outputs = model(images)
+                loss = criterion(outputs, labels)
+                val_loss += loss.item() * images.size(0)
+                val_correct += (outputs.argmax(1) == labels).sum().item()
+
+        val_loss /= len(val_loader.dataset)
+        val_acc = val_correct / len(val_loader.dataset)
+
+        print(f"Epoch {epoch+1}/{epochs} — Train loss: {train_loss:.4f}, Train acc: {train_acc:.4f}, Val loss: {val_loss:.4f}, Val acc: {val_acc:.4f}")
+
+    os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    torch.save({
+        'model_state_dict': model.state_dict(),
+        'class_names': class_names
+    }, save_path)
+    print(f"Model saved to {save_path}")
+
+if __name__ == "__main__":
+    train_model()

utils/metrics.py

@@ -0,0 +1,5 @@
+import torch
+
+def accuracy(outputs, labels):
+    _, preds = torch.max(outputs, 1)
+    return torch.sum(preds == labels).item() / len(labels)

utils/transforms.py

@@ -0,0 +1,18 @@
+from torchvision import transforms
+
+def get_transforms(train=True):
+    if train:
+        return transforms.Compose([
+            transforms.Resize((150, 150)),
+            transforms.RandomHorizontalFlip(),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                                 std=[0.229, 0.224, 0.225])
+        ])
+    else:
+        return transforms.Compose([
+            transforms.Resize((150, 150)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                                 std=[0.229, 0.224, 0.225])
+        ])