Uploaded Complete App

app.py

@@ -0,0 +1,48 @@
+import streamlit as st
+import torch
+import torch.nn as nn
+from torchvision import models, transforms
+from PIL import Image
+import os
+
+# Load class names from your training dataset
+CLASS_NAMES = sorted(os.listdir("oxford_pet_dataset/train"))  # ensure these match training classes
+
+# Load the model
+@st.cache_resource
+def load_model():
+    model = models.resnet18(pretrained=False)
+    model.fc = nn.Linear(model.fc.in_features, len(CLASS_NAMES))
+    model.load_state_dict(torch.load("pet_classifier.pth", map_location=torch.device("cpu")))
+    model.eval()
+    return model
+
+model = load_model()
+
+# Image transform (should match training)
+transform = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize([0.5]*3, [0.5]*3)
+])
+
+# Streamlit UI
+st.title("🐾 Oxford Pet Classifier")
+st.write("Upload a photo of a cat or dog and I’ll try to guess the breed!")
+
+uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
+
+if uploaded_file is not None:
+    image = Image.open(uploaded_file).convert("RGB")
+    st.image(image, caption="Uploaded Image", use_column_width=True)
+
+    # Preprocess
+    input_tensor = transform(image).unsqueeze(0)  # (1, 3, 224, 224)
+
+    # Predict
+    with torch.no_grad():
+        outputs = model(input_tensor)
+        _, predicted = torch.max(outputs, 1)
+        predicted_label = CLASS_NAMES[predicted.item()]
+
+    st.markdown(f"### 🐕 Prediction: **{predicted_label.title()}**")

models/python/dataset_dl.py

@@ -0,0 +1,70 @@
+import os
+import tarfile
+import urllib.request
+from pathlib import Path
+from sklearn.model_selection import train_test_split
+import shutil
+from collections import defaultdict
+
+# URLs
+images_url = "https://www.robots.ox.ac.uk/~vgg/data/pets/data/images.tar.gz"
+annotations_url = "https://www.robots.ox.ac.uk/~vgg/data/pets/data/annotations.tar.gz"
+
+# Paths
+root_dir = Path("oxford_pet_dataset")
+images_tar = root_dir / "images.tar.gz"
+annotations_tar = root_dir / "annotations.tar.gz"
+images_dir = root_dir / "images"
+annotations_dir = root_dir / "annotations"
+
+# Create directory
+root_dir.mkdir(exist_ok=True)
+
+# Download function
+def download(url, path):
+    if not path.exists():
+        print(f"Downloading {url}...")
+        urllib.request.urlretrieve(url, path)
+        print(f"Downloaded to {path}")
+    else:
+        print(f"{path.name} already exists.")
+
+# Extract function
+def extract(tar_path, extract_to):
+    if not extract_to.exists():
+        print(f"Extracting {tar_path.name}...")
+        with tarfile.open(tar_path) as tar:
+            tar.extractall(path=extract_to.parent)
+        print(f"Extracted to {extract_to}")
+    else:
+        print(f"{extract_to.name} already extracted.")
+
+# Download and extract
+download(images_url, images_tar)
+download(annotations_url, annotations_tar)
+extract(images_tar, images_dir)
+extract(annotations_tar, annotations_dir)
+
+# Function to extract class name from filename
+def get_class_name(filename):
+    # Format: 'Abyssinian_123.jpg' → 'abyssinian'
+    return filename.name.split("_")[0].lower()
+
+# Group image files by class
+class_to_files = defaultdict(list)
+for img_path in images_dir.glob("*.jpg"):
+    cls = get_class_name(img_path)
+    class_to_files[cls].append(img_path)
+
+# Split each class into train/val/test and copy
+for cls, files in class_to_files.items():
+    train_cls, testval_cls = train_test_split(files, test_size=0.2, random_state=42)
+    val_cls, test_cls = train_test_split(testval_cls, test_size=0.5, random_state=42)
+
+    for split_name, split_data in zip(["train", "val", "test"], [train_cls, val_cls, test_cls]):
+        split_cls_dir = root_dir / split_name / cls
+        split_cls_dir.mkdir(parents=True, exist_ok=True)
+        for file in split_data:
+            shutil.copy(file, split_cls_dir / file.name)
+
+print("✅ Dataset is now organized by class for ImageFolder.")

models/python/train.py

@@ -0,0 +1,92 @@
+import os
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torchvision import datasets, transforms, models
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+from pathlib import Path
+
+# Set device
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Paths
+root_dir = Path("/oxford_pet_dataset")
+train_dir = root_dir / "train"
+val_dir = root_dir / "val"
+
+# Parameters
+BATCH_SIZE = 32
+EPOCHS = 10
+NUM_CLASSES = len(os.listdir(train_dir))  # Assumes one folder per class
+
+# Transforms
+train_transforms = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.RandomHorizontalFlip(),
+    transforms.ToTensor(),
+    transforms.Normalize([0.5]*3, [0.5]*3)
+])
+
+val_transforms = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize([0.5]*3, [0.5]*3)
+])
+
+# Datasets
+train_dataset = datasets.ImageFolder(train_dir, transform=train_transforms)
+val_dataset = datasets.ImageFolder(val_dir, transform=val_transforms)
+
+# DataLoaders
+train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)
+val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE)
+
+# Model
+model = models.resnet18(pretrained=True)
+model.fc = nn.Linear(model.fc.in_features, NUM_CLASSES)
+model = model.to(device)
+
+# Loss and optimizer
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.Adam(model.parameters(), lr=1e-4)
+
+# Training loop
+for epoch in range(EPOCHS):
+    model.train()
+    train_loss, train_correct = 0.0, 0
+
+    for inputs, labels in tqdm(train_loader, desc=f"Epoch {epoch+1}/{EPOCHS} [Train]"):
+        inputs, labels = inputs.to(device), labels.to(device)
+
+        optimizer.zero_grad()
+        outputs = model(inputs)
+        loss = criterion(outputs, labels)
+        loss.backward()
+        optimizer.step()
+
+        train_loss += loss.item() * inputs.size(0)
+        train_correct += (outputs.argmax(1) == labels).sum().item()
+
+    train_acc = train_correct / len(train_dataset)
+
+    # Validation
+    model.eval()
+    val_loss, val_correct = 0.0, 0
+
+    with torch.no_grad():
+        for inputs, labels in tqdm(val_loader, desc=f"Epoch {epoch+1}/{EPOCHS} [Val]"):
+            inputs, labels = inputs.to(device), labels.to(device)
+            outputs = model(inputs)
+            loss = criterion(outputs, labels)
+
+            val_loss += loss.item() * inputs.size(0)
+            val_correct += (outputs.argmax(1) == labels).sum().item()
+
+    val_acc = val_correct / len(val_dataset)
+
+    print(f"Epoch {epoch+1}: Train Acc: {train_acc:.4f}, Val Acc: {val_acc:.4f}")
+
+# Save model
+torch.save(model.state_dict(), "pet_classifier.pth")
+print("Model saved as pet_classifier.pth")

pet_classifier.pth

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