Update app.py

app.py

@@ -1,34 +1,29 @@
-# app.py - Fashion Classification with Fashion-CLIP + Smart Color Detection
+# app.py - Fashion Classification with PRETRAINED Color Detection
 
 import gradio as gr
-from transformers import CLIPProcessor, CLIPModel
+from transformers import CLIPProcessor, CLIPModel, pipeline
 from PIL import Image
 import torch
 import numpy as np
-import cv2
-from sklearn.cluster import KMeans
 
 # ======================
-# Fashion-CLIP Model Configuration
+# Model Configuration
 # ======================
-MODEL_NAME = "patrickjohncyh/fashion-clip"
+print("[INFO] Loading models...")
 
-print("[INFO] Loading Fashion-CLIP model...")
-model = CLIPModel.from_pretrained(MODEL_NAME)
-processor = CLIPProcessor.from_pretrained(MODEL_NAME)
-print("[SUCCESS] Fashion-CLIP model loaded!")
+# Fashion Classification Model
+FASHION_MODEL = "patrickjohncyh/fashion-clip"
+fashion_model = CLIPModel.from_pretrained(FASHION_MODEL)
+fashion_processor = CLIPProcessor.from_pretrained(FASHION_MODEL)
+print("[SUCCESS] ✅ Fashion-CLIP loaded!")
 
-# Try to import background removal library
-try:
-    from rembg import remove
-    REMBG_AVAILABLE = True
-    print("[SUCCESS] Background removal (rembg) available!")
-except ImportError:
-    REMBG_AVAILABLE = False
-    print("[WARNING] rembg not available. Install with: pip install rembg")
+# Color Detection Model - Using CLIP for color detection
+color_model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
+color_processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
+print("[SUCCESS] ✅ Color Detection Model (CLIP) loaded!")
 
 # ======================
-# Define Fashion Categories
+# Fashion Categories
 # ======================
 FASHION_CATEGORIES = [
     # Indian Wear
@@ -47,243 +42,152 @@ FASHION_CATEGORIES = [
 ]
 
 # ======================
-# Background Removal
+# Comprehensive Color List for CLIP
 # ======================
-def remove_background(image):
-    """
-    Remove background from image - clothing only
-    """
-    if REMBG_AVAILABLE:
-        try:
-            # Use rembg for high-quality background removal
-            output = remove(image)
-            print("[INFO] ✅ Background removed using rembg")
-            return output
-        except Exception as e:
-            print(f"[WARNING] rembg failed: {e}")
-    
-    # Fallback: Use GrabCut
-    try:
-        img_cv = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
-        mask = np.zeros(img_cv.shape[:2], np.uint8)
-        
-        bgd_model = np.zeros((1, 65), np.float64)
-        fgd_model = np.zeros((1, 65), np.float64)
-        
-        height, width = img_cv.shape[:2]
-        margin_h = int(height * 0.05)
-        margin_w = int(width * 0.05)
-        rect = (margin_w, margin_h, width - 2*margin_w, height - 2*margin_h)
-        
-        cv2.grabCut(img_cv, mask, rect, bgd_model, fgd_model, 5, cv2.GC_INIT_WITH_RECT)
-        
-        mask2 = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8')
-        img_cv = img_cv * mask2[:, :, np.newaxis]
-        
-        img_rgb = cv2.cvtColor(img_cv, cv2.COLOR_BGR2RGB)
-        alpha = (mask2 * 255).astype(np.uint8)
-        img_rgba = np.dstack((img_rgb, alpha))
-        
-        print("[INFO] ✅ Background removed using GrabCut")
-        return Image.fromarray(img_rgba, 'RGBA')
-        
-    except Exception as e:
-        print(f"[ERROR] Background removal failed: {e}")
-        return image
+COLOR_LABELS = [
+    # Basic Colors
+    "red", "blue", "green", "yellow", "orange", "purple", "pink", 
+    "brown", "black", "white", "gray", "grey",
+    
+    # Reds
+    "dark red", "light red", "crimson", "maroon", "burgundy", 
+    "wine red", "cherry red", "scarlet",
+    
+    # Pinks
+    "light pink", "hot pink", "coral", "salmon", "rose pink",
+    "baby pink", "magenta", "fuchsia",
+    
+    # Oranges
+    "dark orange", "light orange", "peach", "tangerine", 
+    "rust orange", "burnt orange",
+    
+    # Yellows
+    "light yellow", "dark yellow", "golden yellow", "lemon yellow",
+    "mustard yellow", "cream yellow", "amber",
+    
+    # Greens
+    "dark green", "light green", "forest green", "olive green",
+    "mint green", "lime green", "emerald green", "sage green",
+    "teal", "sea green",
+    
+    # Blues
+    "dark blue", "light blue", "navy blue", "royal blue", 
+    "sky blue", "baby blue", "turquoise", "cyan", "aqua",
+    "indigo", "cobalt blue", "denim blue", "steel blue",
+    
+    # Purples
+    "dark purple", "light purple", "violet", "lavender", 
+    "plum", "orchid", "mauve", "lilac",
+    
+    # Browns
+    "dark brown", "light brown", "chocolate brown", "tan",
+    "beige", "khaki", "caramel", "coffee brown",
+    "taupe", "sand", "bronze",
+    
+    # Grays
+    "light gray", "dark gray", "charcoal", "silver", 
+    "ash gray", "slate gray", "stone gray",
+    
+    # Special
+    "gold", "silver", "copper", "cream", "ivory", "off-white",
+    "wine", "burgundy", "rust", "denim", "multicolor"
+]
+
+# Prepare color prompts for better detection
+COLOR_PROMPTS = [f"a {color} colored clothing item" for color in COLOR_LABELS]
 
 
 # ======================
-# Dominant Color Detection using K-Means
+# Color Detection using CLIP (Pretrained)
 # ======================
-def get_dominant_color(image, n_colors=3):
+def detect_color_with_clip(image, top_k=3):
     """
-    Get THE most dominant colors from clothing using K-means clustering
+    Detect color using pretrained CLIP model
     
-    Returns: List of color names and their RGB values
+    Returns: List of (color_name, confidence_score)
     """
     try:
-        # Step 1: Remove background
-        print("[INFO] 🔄 Removing background...")
-        img_no_bg = remove_background(image)
-        
-        # Step 2: Convert to numpy array
-        img_array = np.array(img_no_bg)
-        
-        # Step 3: Extract only non-transparent pixels (clothing only)
-        if img_array.shape[-1] == 4:  # RGBA
-            alpha = img_array[:, :, 3]
-            mask = alpha > 100
-            pixels = img_array[:, :, :3][mask]
-        else:  # RGB
-            pixels = img_array.reshape(-1, 3)
-        
-        # Step 4: Filter out pure white and pure black
-        pixels = pixels[~((pixels[:, 0] > 240) & (pixels[:, 1] > 240) & (pixels[:, 2] > 240))]
-        pixels = pixels[~((pixels[:, 0] < 15) & (pixels[:, 1] < 15) & (pixels[:, 2] < 15))]
-        
-        if len(pixels) < 10:
-            return ["Unable to detect"], None
+        print("[INFO] 🎨 Detecting colors with CLIP model...")
         
-        print(f"[INFO] 📊 Analyzing {len(pixels)} clothing pixels...")
-        
-        # Step 5: Sample pixels if too many
-        if len(pixels) > 5000:
-            indices = np.random.choice(len(pixels), 5000, replace=False)
-            pixels = pixels[indices]
-        
-        # Step 6: K-Means clustering
-        kmeans = KMeans(n_clusters=min(n_colors, len(pixels)), random_state=42, n_init=10)
-        kmeans.fit(pixels)
+        # Prepare inputs
+        inputs = color_processor(
+            text=COLOR_PROMPTS,
+            images=image,
+            return_tensors="pt",
+            padding=True
+        )
         
-        # Step 7: Get cluster centers
-        dominant_colors_rgb = kmeans.cluster_centers_
+        # Get predictions
+        with torch.no_grad():
+            outputs = color_model(**inputs)
         
-        # Step 8: Sort by frequency
-        labels = kmeans.labels_
-        label_counts = np.bincount(labels)
-        sorted_indices = np.argsort(label_counts)[::-1]
+        # Calculate probabilities
+        logits_per_image = outputs.logits_per_image
+        probs = logits_per_image.softmax(dim=1)[0]
         
-        # Step 9: Convert to color names
-        color_names = []
-        color_rgb_values = []
+        # Get top K colors
+        top_probs, top_indices = torch.topk(probs, k=top_k)
         
-        for idx in sorted_indices[:n_colors]:
-            rgb = dominant_colors_rgb[idx].astype(int)
-            color_name = rgb_to_color_name(tuple(rgb))
+        detected_colors = []
+        for prob, idx in zip(top_probs, top_indices):
+            color_name = COLOR_LABELS[idx.item()]
+            confidence = prob.item()
             
-            if color_name not in color_names:
-                color_names.append(color_name)
-                color_rgb_values.append(rgb)
+            # Only include if confidence > 5%
+            if confidence > 0.05:
+                detected_colors.append((color_name, confidence))
+                print(f"[INFO]    - {color_name}: {confidence:.1%}")
         
-        print(f"[INFO] 🎨 Dominant colors detected: {', '.join(color_names)}")
+        if not detected_colors:
+            return [("unknown", 0.0)]
         
-        return color_names, color_rgb_values
+        return detected_colors
         
     except Exception as e:
         print(f"[ERROR] Color detection failed: {e}")
         import traceback
         traceback.print_exc()
-        return ["Detection Failed"], None
+        return [("detection failed", 0.0)]
 
 
-def rgb_to_color_name(rgb):
+# ======================
+# Alternative: Using Image Classification Pipeline
+# ======================
+def detect_color_with_pipeline(image):
     """
-    Convert RGB to human-readable color name
+    Alternative: Using HuggingFace image classification pipeline
     """
-    r, g, b = rgb
-    
-    # White
-    if r > 220 and g > 220 and b > 220:
-        return "White"
-    
-    # Black
-    if r < 40 and g < 40 and b < 40:
-        return "Black"
-    
-    # Gray
-    if abs(r - g) < 30 and abs(g - b) < 30 and 40 <= r <= 220:
-        if r > 160:
-            return "Light Gray"
-        elif r > 100:
-            return "Gray"
-        else:
-            return "Dark Gray"
-    
-    # Red family
-    if r > max(g, b) + 30:
-        if r > 200 and g < 100:
-            return "Red"
-        elif r > 150 and g > 50 and g < 150:
-            if b < 80:
-                return "Orange"
-            else:
-                return "Coral"
-        elif r > 100 and g < 80 and b < 80:
-            return "Maroon"
-        elif r > 180 and b > 100:
-            return "Pink"
-    
-    # Orange
-    if r > 200 and 100 < g < 180 and b < 100:
-        return "Orange"
-    
-    # Yellow
-    if r > 200 and g > 200 and b < 150:
-        if b < 80:
-            return "Yellow"
-        else:
-            return "Light Yellow"
-    
-    # Green family
-    if g > max(r, b) + 30:
-        if g > 200 and r > 150:
-            return "Light Green"
-        elif g > 150 and r < 100 and b < 100:
-            return "Green"
-        elif g > 100 and r > 80 and b < 80:
-            return "Olive"
-        elif r < 100 and b < 100:
-            return "Dark Green"
-    
-    # Blue family
-    if b > max(r, g) + 30:
-        if b > 200 and r < 100 and g < 100:
-            return "Blue"
-        elif b > 150 and r < 80 and g < 80:
-            return "Navy"
-        elif b > 150 and g > 100:
-            return "Sky Blue"
-        elif b > 100 and r > 80 and g < 100:
-            return "Purple"
-    
-    # Cyan/Turquoise
-    if g > 150 and b > 150 and r < 100:
-        return "Cyan"
-    
-    # Purple/Violet
-    if r > 100 and b > 100 and g < 100:
-        if r > 150 and b > 150:
-            return "Purple"
-        elif r > b:
-            return "Magenta"
-        else:
-            return "Violet"
-    
-    # Pink
-    if r > 180 and b > 120 and g < 150:
-        return "Pink"
-    
-    # Brown
-    if 80 < r < 180 and 40 < g < 140 and b < 100:
-        if r > 140:
-            return "Brown"
-        else:
-            return "Dark Brown"
-    
-    # Beige/Tan
-    if r > 180 and g > 150 and b > 100 and r > b:
-        return "Beige"
-    
-    # Gold
-    if r > 200 and 140 < g < 200 and b < 100:
-        return "Gold"
-    
-    # Cream
-    if r > 220 and g > 200 and 150 < b < 200:
-        return "Cream"
-    
-    # Lavender
-    if r > 180 and g > 160 and b > 200:
-        return "Lavender"
-    
-    # Default
-    return "Multicolor"
+    try:
+        # Load a pretrained color classification model
+        # You can replace this with a specific color detection model if available
+        classifier = pipeline("image-classification", model="google/vit-base-patch16-224")
+        
+        results = classifier(image)
+        
+        # Filter for color-related predictions
+        color_keywords = ['red', 'blue', 'green', 'yellow', 'orange', 'purple', 
+                         'pink', 'brown', 'black', 'white', 'gray', 'grey']
+        
+        color_results = []
+        for result in results:
+            label_lower = result['label'].lower()
+            for color in color_keywords:
+                if color in label_lower:
+                    color_results.append((color, result['score']))
+                    break
+        
+        return color_results if color_results else [("multicolor", 0.5)]
+        
+    except Exception as e:
+        print(f"[ERROR] Pipeline color detection failed: {e}")
+        return [("unknown", 0.0)]
 
 
+# ======================
+# Clothing Type Detection
+# ======================
 def detect_clothing_type(category):
-    """
-    Detect if Indian or Western wear
-    """
+    """Detect if Indian or Western wear"""
     indian_wear = [
         'saree', 'kurta', 'salwar', 'lehenga', 'sherwani', 
         'churidar', 'anarkali', 'kurti', 'dhoti', 'palazzo'
@@ -298,66 +202,67 @@ def detect_clothing_type(category):
     return "🌍 Western Wear"
 
 
+# ======================
+# Color Emoji Mapping
+# ======================
 def get_color_emoji(color_name):
-    """
-    Get emoji for color (visual representation)
-    """
-    color_emojis = {
-        "Red": "🔴",
-        "Blue": "🔵",
-        "Green": "🟢",
-        "Yellow": "🟡",
-        "Orange": "🟠",
-        "Purple": "🟣",
-        "Pink": "🩷",
-        "Brown": "🟤",
-        "Black": "⚫",
-        "White": "⚪",
-        "Gray": "⚫",
-        "Light Gray": "⚪",
-        "Dark Gray": "⚫",
-        "Navy": "🔵",
-        "Sky Blue": "🔵",
-        "Light Green": "🟢",
-        "Dark Green": "🟢",
-        "Maroon": "🔴",
-        "Coral": "🩷",
-        "Gold": "🟡",
-        "Beige": "🟤",
-        "Cream": "⚪",
-        "Olive": "🟢",
-        "Cyan": "🔵",
-        "Magenta": "🟣",
-        "Violet": "🟣",
-        "Lavender": "🟣",
-        "Light Yellow": "🟡",
-        "Dark Brown": "🟤",
-        "Multicolor": "🌈"
-    }
-    
-    return color_emojis.get(color_name, "🎨")
+    """Get emoji for color"""
+    color_lower = color_name.lower()
+    
+    if 'red' in color_lower or 'crimson' in color_lower or 'scarlet' in color_lower:
+        return "🔴"
+    elif 'pink' in color_lower or 'rose' in color_lower or 'coral' in color_lower:
+        return "🩷"
+    elif 'orange' in color_lower or 'peach' in color_lower or 'rust' in color_lower:
+        return "🟠"
+    elif 'yellow' in color_lower or 'gold' in color_lower or 'amber' in color_lower:
+        return "🟡"
+    elif 'green' in color_lower or 'olive' in color_lower or 'lime' in color_lower or 'emerald' in color_lower:
+        return "🟢"
+    elif 'blue' in color_lower or 'navy' in color_lower or 'cyan' in color_lower or 'aqua' in color_lower or 'denim' in color_lower:
+        return "🔵"
+    elif 'purple' in color_lower or 'violet' in color_lower or 'lavender' in color_lower or 'plum' in color_lower:
+        return "🟣"
+    elif 'brown' in color_lower or 'tan' in color_lower or 'beige' in color_lower or 'khaki' in color_lower:
+        return "🟤"
+    elif 'black' in color_lower or 'dark' in color_lower or 'charcoal' in color_lower:
+        return "⚫"
+    elif 'white' in color_lower or 'cream' in color_lower or 'ivory' in color_lower:
+        return "⚪"
+    elif 'gray' in color_lower or 'grey' in color_lower or 'silver' in color_lower:
+        return "⚪"
+    else:
+        return "🎨"
+
+
+# ======================
+# Format Color Name
+# ======================
+def format_color_name(color):
+    """Format color name to title case"""
+    return color.replace('_', ' ').title()
 
 
 # ======================
-# Prediction Function
+# Main Prediction Function
 # ======================
 def predict_fashion(image, custom_categories=None):
     """
-    Classify fashion item + detect dominant color (TEXT OUTPUT)
+    Classify fashion item + detect color using PRETRAINED models
     """
     if image is None:
         return "⚠️ Please upload an image first!", {}
     
     try:
-        # Step 1: Categories
+        # Step 1: Prepare Categories
         if custom_categories and custom_categories.strip():
             categories = [cat.strip() for cat in custom_categories.split(",")]
         else:
             categories = FASHION_CATEGORIES
         
-        # Step 2: Fashion Classification
+        # Step 2: Fashion Item Classification
         print("[INFO] 🔍 Classifying fashion item...")
-        inputs = processor(
+        inputs = fashion_processor(
             text=categories,
             images=image,
             return_tensors="pt",
@@ -365,7 +270,7 @@ def predict_fashion(image, custom_categories=None):
         )
         
         with torch.no_grad():
-            outputs = model(**inputs)
+            outputs = fashion_model(**inputs)
         
         logits_per_image = outputs.logits_per_image
         probs = logits_per_image.softmax(dim=1)[0]
@@ -374,14 +279,13 @@ def predict_fashion(image, custom_categories=None):
         top_category = categories[top_prob_idx]
         top_confidence = probs[top_prob_idx].item()
         
-        # Step 3: Dominant Color Detection
-        print("[INFO] 🎨 Detecting dominant colors...")
-        dominant_colors, rgb_values = get_dominant_color(image, n_colors=3)
+        # Step 3: Color Detection with CLIP (Pretrained)
+        detected_colors = detect_color_with_clip(image, top_k=3)
         
-        # Step 4: Type Detection
+        # Step 4: Clothing Type
         clothing_type = detect_clothing_type(top_category)
         
-        # Step 5: Format result with TEXT COLORS
+        # Step 5: Format Results
         result = f"""
 ### 🎯 Fashion Item Detected
 
@@ -391,48 +295,52 @@ def predict_fashion(image, custom_categories=None):
 
 ---
 
-### 🎨 Detected Colors (Text Format)
+### 🎨 Color Detection (Pretrained CLIP Model)
 
 """
         
-        # ✅ DISPLAY COLORS AS TEXT
-        if dominant_colors and dominant_colors[0] != "Unable to detect":
+        # Display detected colors
+        if detected_colors and detected_colors[0][0] not in ["unknown", "detection failed"]:
             # Primary Color
-            primary_color = dominant_colors[0]
+            primary_color, primary_conf = detected_colors[0]
+            primary_formatted = format_color_name(primary_color)
             primary_emoji = get_color_emoji(primary_color)
-            primary_rgb = rgb_values[0] if rgb_values else [0, 0, 0]
             
-            result += f"**Primary Color:** {primary_emoji} **{primary_color}** ✨\n"
-            result += f"*RGB Values: ({primary_rgb[0]}, {primary_rgb[1]}, {primary_rgb[2]})*\n\n"
+            result += f"**Primary Color:** {primary_emoji} **{primary_formatted}** ✨\n"
+            result += f"*Confidence: {primary_conf:.1%}*\n\n"
             
             # Secondary Colors
-            if len(dominant_colors) > 1:
+            if len(detected_colors) > 1:
                 result += "**Secondary Colors:**\n"
-                for i, (color, rgb) in enumerate(zip(dominant_colors[1:], rgb_values[1:]), 1):
+                for i, (color, conf) in enumerate(detected_colors[1:], 1):
+                    formatted = format_color_name(color)
                     emoji = get_color_emoji(color)
-                    result += f"  {i}. {emoji} **{color}** - RGB({rgb[0]}, {rgb[1]}, {rgb[2]})\n"
+                    result += f"  {i}. {emoji} **{formatted}** ({conf:.1%})\n"
                 result += "\n"
             
             # Color Summary
-            result += f"**Color Summary:** {', '.join(dominant_colors)} 🌈\n"
+            color_names = [format_color_name(c[0]) for c in detected_colors]
+            result += f"**Color Summary:** {', '.join(color_names)} 🌈\n"
         else:
-            result += "⚠️ Unable to detect colors from image\n"
+            result += f"⚠️ Color detection: {detected_colors[0][0]}\n"
         
         result += f"""
 ---
 
 ### 📊 Detection Details
 
-✅ Background removed automatically  
-🎨 K-means clustering used for color detection  
-🔍 Classification confidence: **{top_confidence:.1%}**  
-📸 Analyzed against **{len(categories)}** categories
+✅ **Fashion Model:** Fashion-CLIP (pretrained)  
+🎨 **Color Model:** CLIP Vision Transformer (pretrained)  
+🔍 **Color Database:** {len(COLOR_LABELS)} color categories  
+📊 **Classification Confidence:** {top_confidence:.1%}  
+🧠 **Method:** Zero-shot learning (no training needed)
 
 ---
 
 ### 💡 Styling Suggestions
 """
         
+        # Clothing type suggestions
         if "Indian" in clothing_type:
             result += """
 - Perfect for traditional occasions 🪔
@@ -446,34 +354,36 @@ def predict_fashion(image, custom_categories=None):
 - Suitable for casual/formal settings
 """
         
-        # Color-based suggestions
-        if dominant_colors[0] != "Unable to detect":
-            primary = dominant_colors[0].lower()
+        # Color-specific styling tips
+        if detected_colors and detected_colors[0][0] not in ["unknown", "detection failed"]:
+            primary_color = detected_colors[0][0].lower()
             
-            result += f"\n**Color Styling Tips for {dominant_colors[0]}:**\n"
+            result += f"\n**Styling Tips for {format_color_name(detected_colors[0][0])}:**\n"
             
-            if "black" in primary:
-                result += "- Classic and versatile ⚫\n- Pairs well with any color\n- Perfect for formal events\n"
-            elif "white" in primary:
-                result += "- Clean and fresh look ⚪\n- Great for summer\n- Easy to accessorize\n"
-            elif "red" in primary:
-                result += "- Bold and confident 🔴\n- Statement piece\n- Pair with neutral colors\n"
-            elif "blue" in primary:
-                result += "- Cool and calming 🔵\n- Professional look\n- Versatile for day/night\n"
-            elif "green" in primary:
-                result += "- Natural and refreshing 🟢\n- Great for outdoor events\n- Pairs with earth tones\n"
-            elif "yellow" in primary or "gold" in primary:
-                result += "- Bright and cheerful 🟡\n- Perfect for festivities\n- Eye-catching choice\n"
-            elif "pink" in primary:
-                result += "- Soft and feminine 🩷\n- Romantic vibe\n- Great for parties\n"
-            elif "purple" in primary or "violet" in primary:
-                result += "- Royal and elegant 🟣\n- Sophisticated choice\n- Unique statement\n"
-            elif "brown" in primary or "beige" in primary:
-                result += "- Earthy and warm 🟤\n- Natural aesthetic\n- Timeless appeal\n"
-            elif "gray" in primary:
-                result += "- Neutral and modern ⚫\n- Professional look\n- Easy to style\n"
-        
-        # Top predictions
+            if 'black' in primary_color or 'dark' in primary_color:
+                result += "- Timeless and elegant ⚫\n- Pairs with everything\n- Perfect for formal occasions\n"
+            elif 'white' in primary_color or 'cream' in primary_color or 'ivory' in primary_color:
+                result += "- Fresh and clean ⚪\n- Summer favorite\n- Easy to accessorize\n"
+            elif 'gray' in primary_color or 'grey' in primary_color or 'silver' in primary_color:
+                result += "- Sophisticated neutral ⚫\n- Professional choice\n- Modern aesthetic\n"
+            elif 'red' in primary_color or 'maroon' in primary_color or 'crimson' in primary_color:
+                result += "- Bold statement 🔴\n- Confidence booster\n- Pair with neutrals\n"
+            elif 'blue' in primary_color or 'navy' in primary_color or 'denim' in primary_color:
+                result += "- Classic choice 🔵\n- Versatile wear\n- Calming effect\n"
+            elif 'green' in primary_color or 'olive' in primary_color:
+                result += "- Natural vibe 🟢\n- Fresh look\n- Great for outdoors\n"
+            elif 'yellow' in primary_color or 'gold' in primary_color:
+                result += "- Cheerful color 🟡\n- Festive choice\n- Eye-catching\n"
+            elif 'pink' in primary_color or 'coral' in primary_color:
+                result += "- Soft and feminine 🩷\n- Romantic appeal\n- Party ready\n"
+            elif 'purple' in primary_color or 'violet' in primary_color:
+                result += "- Royal elegance 🟣\n- Unique choice\n- Sophisticated\n"
+            elif 'brown' in primary_color or 'tan' in primary_color or 'beige' in primary_color:
+                result += "- Earthy warmth 🟤\n- Natural look\n- Timeless style\n"
+            elif 'orange' in primary_color or 'peach' in primary_color:
+                result += "- Vibrant energy 🟠\n- Playful choice\n- Summer perfect\n"
+        
+        # Top fashion predictions
         top_probs, top_indices = torch.topk(probs, k=min(5, len(categories)))
         top_predictions = {}
         for prob, idx in zip(top_probs, top_indices):
@@ -491,27 +401,25 @@ def predict_fashion(image, custom_categories=None):
 # ======================
 # Gradio Interface
 # ======================
-with gr.Blocks(title="Fashion-CLIP + Color Detection", theme=gr.themes.Soft()) as demo:
+with gr.Blocks(title="Fashion AI with Pretrained Color Detection", theme=gr.themes.Soft()) as demo:
     
     gr.Markdown("""
-    # 👗 AI Fashion Classifier with Smart Color Detection
-    ### Background Removal + K-Means Clustering for Accurate Colors (Text Output)
+    # 👗 AI Fashion Classifier with Pretrained Color Detection
+    ### Using CLIP Vision Transformer for Zero-Shot Color Recognition
     """)
     
-    status = "🟢 High Quality (rembg)" if REMBG_AVAILABLE else "🟡 Standard (GrabCut)"
-    
     gr.Markdown(f"""
-    **Model:** Fashion-CLIP  
-    **Color Detection:** K-Means Clustering  
-    **Background Removal:** {status}  
-    **Output Format:** Text-based color names with RGB values
-    
-    ### ✨ How it works:
-    1. 🖼️ **Upload** your fashion item image
-    2. 🔄 **Background** is automatically removed
-    3. 🎨 **K-means** finds the dominant colors from clothing only
-    4. 👗 **Fashion-CLIP** classifies the item type
-    5. 📝 **Colors displayed as text** with emojis and RGB values
+    **Fashion Model:** Fashion-CLIP (pretrained)  
+    **Color Model:** OpenAI CLIP ViT-B/32 (pretrained)  
+    **Color Categories:** {len(COLOR_LABELS)} colors  
+    **Method:** Zero-shot learning (no dataset training needed)
+    
+    ### ✨ Why Pretrained Models?
+    1. 🎯 **Highly Accurate** - Trained on millions of images
+    2. ⚡ **Fast** - No preprocessing needed
+    3. 🧠 **Smart** - Understands context and variations
+    4. 🔄 **Generalizable** - Works on any clothing type
+    5. 📊 **Reliable** - Consistent results
     """)
     
     with gr.Row():
@@ -520,81 +428,93 @@ with gr.Blocks(title="Fashion-CLIP + Color Detection", theme=gr.themes.Soft()) a
             
             custom_categories = gr.Textbox(
                 label="🏷️ Custom Categories (Optional)",
-                placeholder="red saree, blue kurta, black jeans, white shirt",
+                placeholder="gray shorts, blue jeans, red kurta, white shirt",
                 info="Comma-separated. Leave empty for 50+ default categories."
             )
             
-            predict_btn = gr.Button("🔍 Analyze Fashion Item", variant="primary", size="lg")
+            predict_btn = gr.Button("🔍 Analyze with AI Models", variant="primary", size="lg")
             
             gr.Markdown("""
             **💡 Tips:**
-            - Clear, well-lit photos work best
-            - Single clothing item preferred
-            - Background will be auto-removed
-            - Colors shown as text with RGB values
+            - Clear photos work best
+            - Good lighting recommended
+            - Single item preferred
             
-            **📦 For Best Results:**
-            ```bash
-            pip install rembg scikit-learn
-            ```
-            """)
+            **🎨 Supported Colors ({} types):**
+            - Basic: Red, Blue, Green, Yellow, Orange, Purple, Pink, Brown, Black, White, Gray
+            - Shades: Dark/Light variations
+            - Specific: Navy, Maroon, Teal, Lavender, Beige, etc.
+            
+            **⚡ No Installation Needed:**
+            All models are pretrained and ready to use!
+            """.format(len(COLOR_LABELS)))
         
         with gr.Column():
-            output_text = gr.Markdown(label="📋 Results")
-            output_label = gr.Label(label="📊 Top 5 Predictions", num_top_classes=5)
+            output_text = gr.Markdown(label="📋 AI Analysis Results")
+            output_label = gr.Label(label="📊 Top 5 Item Predictions", num_top_classes=5)
     
-    # Event
+    # Event Handler
     predict_btn.click(
         fn=predict_fashion,
         inputs=[input_image, custom_categories],
         outputs=[output_text, output_label]
     )
     
-    gr.Markdown("""
+    gr.Markdown(f"""
     ---
-    ### 📝 Example Queries
+    ### 📝 Example Test Cases
     
-    | Type | Example Categories |
-    |------|-------------------|
-    | **Indian** | `red saree, green lehenga, blue kurta` |
-    | **Western** | `black jeans, white shirt, blue dress` |
-    | **Formal** | `black suit, white shirt, navy blazer` |
-    | **Footwear** | `white sneakers, black boots, brown sandals` |
+    | Item | Expected Colors |
+    |------|----------------|
+    | **Gray Shorts** | Gray, Light Gray, Dark Gray, Charcoal |
+    | **Denim Jeans** | Denim Blue, Navy Blue, Dark Blue |
+    | **Red Saree** | Red, Crimson, Dark Red |
+    | **White Shirt** | White, Off-White, Cream |
+    | **Black Kurta** | Black, Dark Gray, Charcoal |
+    | **Beige Dress** | Beige, Tan, Light Brown, Cream |
     
     ---
     
-    ### 🎨 Color Output Format:
+    ### 🎨 Color Detection Technology
     
-    **Primary Color:** 🔴 **Red** ✨  
-    *RGB Values: (255, 0, 0)*
+    **Model:** OpenAI CLIP (Contrastive Language-Image Pre-training)
     
-    **Secondary Colors:**  
-      1. ⚪ **White** - RGB(255, 255, 255)  
-      2. ⚫ **Black** - RGB(0, 0, 0)
+    **How it works:**
+    1. Image is processed through Vision Transformer
+    2. Compared with {len(COLOR_LABELS)} color text descriptions
+    3. Returns best matching colors with confidence scores
+    4. No background removal needed
+    5. Context-aware (understands "denim blue" vs "sky blue")
     
-    **Color Summary:** Red, White, Black 🌈
+    **Advantages over traditional methods:**
+    - ✅ Pretrained on 400M+ image-text pairs
+    - ✅ Understands color context (e.g., "denim blue", "burgundy red")
+    - ✅ No manual threshold tuning needed
+    - ✅ Works on complex patterns and textures
+    - ✅ Handles shadows and lighting variations
     
     ---
     
     **🚀 Powered by:**
     - Fashion-CLIP (patrickjohncyh/fashion-clip)
-    - K-Means Clustering for dominant colors
-    - rembg/GrabCut for background removal
-    - Text-based color output with emojis
-    """)
+    - OpenAI CLIP ViT-B/32
+    - HuggingFace Transformers
+    - Zero-shot learning (no training required)
+    """.format(len(COLOR_LABELS)))
 
 # ======================
 # Launch
 # ======================
 if __name__ == "__main__":
     print("\n" + "="*60)
-    print("🚀 FASHION CLASSIFIER WITH SMART COLOR DETECTION (TEXT)")
+    print("🚀 FASHION AI WITH PRETRAINED COLOR DETECTION")
     print("="*60)
-    print(f"✅ Fashion-CLIP Model: Loaded")
-    print(f"✅ Categories: {len(FASHION_CATEGORIES)}")
-    print(f"✅ Background Removal: {'rembg (High Quality)' if REMBG_AVAILABLE else 'GrabCut (Standard)'}")
-    print(f"✅ Color Detection: K-Means Clustering")
-    print(f"✅ Output Format: Text with RGB values")
+    print(f"✅ Fashion Model: Fashion-CLIP (loaded)")
+    print(f"✅ Color Model: CLIP ViT-B/32 (loaded)")
+    print(f"✅ Fashion Categories: {len(FASHION_CATEGORIES)}")
+    print(f"✅ Color Categories: {len(COLOR_LABELS)}")
+    print(f"✅ Method: Zero-shot learning")
+    print(f"✅ Background Removal: Not needed (AI handles it)")
     print("="*60 + "\n")
     
     demo.launch(server_name="0.0.0.0", server_port=7860)