Upload 4 files

CC_net.pt

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

ResNet_for_CC.py

@@ -0,0 +1,93 @@
+import torch
+import torch.nn as nn
+import torchvision.models as models
+
+class ResClassifier(nn.Module):
+    """
+    A classifier with two fully connected layers followed by a final linear layer.
+    Uses BatchNorm, ReLU activations, and Dropout for better generalization.
+    """
+    def __init__(self, num_classes=14):
+        super(ResClassifier, self).__init__()
+        
+        # First fully connected layer: reduces 128D features to 64D
+        self.fc1 = nn.Sequential(
+            nn.Linear(128, 64),
+            nn.BatchNorm1d(64, affine=True),
+            nn.ReLU(inplace=True),
+            nn.Dropout()
+        )
+        
+        # Second fully connected layer: retains 64D features
+        self.fc2 = nn.Sequential(
+            nn.Linear(64, 64),
+            nn.BatchNorm1d(64, affine=True),
+            nn.ReLU(inplace=True),
+            nn.Dropout()
+        )
+        
+        # Final classification layer mapping 64D features to class logits
+        self.fc3 = nn.Linear(64, num_classes)
+
+    def forward(self, x):
+        """
+        Forward pass through the classifier.
+        Returns class logits after two hidden layers.
+        """
+        x = self.fc1(x)  # First FC layer
+        x = self.fc2(x)  # Second FC layer
+        output = self.fc3(x)  # Final classification layer
+        return output
+
+
+class CC_model(nn.Module):
+    """
+    Clothing Classification Model based on ResNet50.
+    Extracts deep features and uses two independent classifiers for predictions.
+    """
+    def __init__(self, num_classes1=14, num_classes2=None):
+        super(CC_model, self).__init__()
+        
+        # If num_classes2 is not specified, default to num_classes1
+        num_classes2 = num_classes2 if num_classes2 else num_classes1
+        assert num_classes1 == num_classes2  # Ensure both classifiers predict the same categories
+        
+        self.num_classes = num_classes1
+        
+        # Load a pretrained ResNet-50 model as the feature extractor
+        self.model_resnet = models.resnet50(weights='ResNet50_Weights.DEFAULT')
+        
+        # Remove ResNet's original classification layer to use as a feature extractor
+        num_ftrs = self.model_resnet.fc.in_features
+        self.model_resnet.fc = nn.Identity()  # Identity layer keeps feature dimensions
+
+        # Additional transformation layer reducing feature size to 128D
+        self.dr = nn.Linear(num_ftrs, 128)
+
+        # Two independent classifiers
+        self.fc1 = ResClassifier(num_classes1)
+        self.fc2 = ResClassifier(num_classes1)
+
+    def forward(self, x, detach_feature=False):
+        """
+        Forward pass through the model.
+        Extracts deep features from ResNet and processes them through classifiers.
+        """
+        with torch.no_grad():
+            # Extract deep features using ResNet-50 (without its original classification head)
+            feature = self.model_resnet(x)
+
+        # Generate transformed features (128D) using the custom linear layer
+        dr_feature = self.dr(feature)
+
+        if detach_feature:
+            dr_feature = dr_feature.detach()  # Detach feature for non-trainable forward pass
+
+        # Pass features through two independent classifiers
+        out1 = self.fc1(dr_feature)
+        out2 = self.fc2(dr_feature)
+
+        # Compute the mean prediction from both classifiers
+        output_mean = (out1 + out2) / 2
+
+        return dr_feature, output_mean  # Returning feature embeddings and final prediction

app.py

@@ -0,0 +1,89 @@
+import gradio as gr
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision.transforms as transforms
+from PIL import Image
+from ResNet_for_CC import CC_model  # Ensure the correct import
+
+# ✅ Detect available device (CPU/GPU)
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"[INFO] Running on: {device}")
+
+# ✅ Load the trained CC_model
+model_path = "CC_net.pt"
+print(f"[INFO] Loading model from: {model_path}")
+
+# Initialize and load model weights
+model = CC_model(num_classes=14)  
+try:
+    state_dict = torch.load(model_path, map_location=device)
+    model.load_state_dict(state_dict, strict=False)
+    model.to(device)
+    model.eval()  # Set to evaluation mode
+    print("[✅] Model loaded successfully!")
+except Exception as e:
+    print(f"[❌ ERROR] Failed to load model: {e}")
+
+# ✅ Define class labels for Clothing1M dataset
+class_labels = [
+    "T-Shirt", "Shirt", "Knitwear", "Chiffon", "Sweater", "Hoodie",
+    "Windbreaker", "Jacket", "Downcoat", "Suit", "Shawl", "Dress",
+    "Vest", "Underwear"
+]
+
+# ✅ Image Preprocessing Pipeline
+transform = transforms.Compose([
+    transforms.Resize((224, 224)),  # Resize to fixed dimensions
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+])
+
+# ✅ Inference Function
+def classify_image(image):
+    """
+    Processes the input image and returns the predicted clothing category.
+    """
+    try:
+        print("\n[DEBUG] Processing input image...")
+
+        # Convert image to tensor and move to device
+        image = transform(image).unsqueeze(0).to(device)
+
+        # Forward pass through the model
+        with torch.no_grad():
+            logits = model(image)  
+        
+        # Validate model output shape
+        if logits.shape[1] != len(class_labels):
+            return f"[❌ ERROR] Model output mismatch! Expected {len(class_labels)}, but got {logits.shape[1]}."
+
+        # Convert logits to probabilities
+        probabilities = F.softmax(logits, dim=1)[0]
+        predicted_index = torch.argmax(probabilities).item()
+        confidence = probabilities[predicted_index].item() * 100
+
+        # ✅ Return formatted prediction
+        predicted_label = class_labels[predicted_index]
+        print(f"[INFO] Prediction: {predicted_label} (Confidence: {confidence:.2f}%)")
+
+        # Return label and confidence
+        return f"Predicted Class: {predicted_label} (Confidence: {confidence:.2f}%)"
+
+    except Exception as e:
+        print(f"[❌ ERROR] Exception during classification: {e}")
+        return "[ERROR] Failed to process image. Please check logs."
+
+# ✅ Create Gradio Interface
+interface = gr.Interface(
+    fn=classify_image, 
+    inputs=gr.Image(type="pil"), 
+    outputs="text",
+    title="👕 Clothing1M Classifier",
+    description="Upload a clothing image, and the AI model will classify it into one of 14 categories."
+)
+
+# ✅ Run the Gradio Interface
+if __name__ == "__main__":
+    print("[INFO] Launching Gradio interface...")
+    interface.launch()

requirements.txt

@@ -0,0 +1,7 @@
+clip==0.2.0
+numpy==1.23.4
+openai_clip==1.0.1
+Pillow==9.4.0
+torch==2.6.0
+torchvision==0.21.0
+tqdm==4.64.1