More robust recommendations overall

inference.py

@@ -382,7 +382,7 @@ class InferenceService:
         if len(proc_items) < 2:
             print("🔍 DEBUG: Returning empty array - not enough items (< 2)")
             return []
-        
+
         print("🔍 DEBUG: Starting candidate generation...")
 
         # 2) Candidate generation with outfit templates
@@ -426,7 +426,7 @@ class InferenceService:
         # Enhanced category-aware pools with diversity checks
         def cat_str(i: int) -> str:
             return (proc_items[i].get("category") or "").lower()
-        
+
         print("🔍 DEBUG: Building category pools...")
         # Debug: Print all categories
         for i in range(len(proc_items)):
@@ -490,6 +490,16 @@ class InferenceService:
             cat_lower = cat.lower().strip()
             print(f"🔍 DEBUG: Mapping category '{cat}' -> '{cat_lower}'")
             
+            # Direct mapping for CLIP-detected categories
+            if cat_lower == "shirt":
+                return "upper"
+            elif cat_lower == "pants":
+                return "bottom"
+            elif cat_lower == "shoes":
+                return "shoe"
+            elif cat_lower == "accessory":
+                return "accessory"
+            
             # Upper body items (tops, outerwear)
             upper_keywords = [
                 "top", "shirt", "tshirt", "t-shirt", "blouse", "tank", "camisole", "cami",
@@ -547,74 +557,131 @@ class InferenceService:
         
         print(f"🔍 DEBUG: Category pools - uppers: {len(uppers)}, bottoms: {len(bottoms)}, shoes: {len(shoes)}, accessories: {len(accs)}, others: {len(others)}")
         
-        # Check if we have the minimum required items
-        if len(uppers) == 0 or len(bottoms) == 0 or len(shoes) == 0:
-            print(f"🔍 DEBUG: Missing required categories - uppers: {len(uppers)}, bottoms: {len(bottoms)}, shoes: {len(shoes)}")
+        # Check if we have enough items to create outfits
+        total_items = len(uppers) + len(bottoms) + len(shoes) + len(accs) + len(others)
+        if total_items < 2:
+            print(f"🔍 DEBUG: Not enough items to create outfits - total: {total_items}")
             return []
+        
+        # Warn if we're missing core categories but still try to generate
+        if len(uppers) == 0 or len(bottoms) == 0 or len(shoes) == 0:
+            print(f"🔍 DEBUG: Missing some core categories - uppers: {len(uppers)}, bottoms: {len(bottoms)}, shoes: {len(shoes)}")
+            print(f"🔍 DEBUG: Will use flexible outfit generation with available items")
 
         candidates: List[List[int]] = []
-        num_samples = max(num_outfits * 12, 24)
+        num_samples = max(num_outfits * 15, 30)  # Increased for more variety
         print(f"🔍 DEBUG: Generating {num_samples} candidate outfits...")
         
         def has_category_diversity(subset: List[int]) -> bool:
             """Check if subset has good category diversity"""
             categories = [get_category_type(cat_str(i)) for i in subset]
             unique_categories = set(categories)
-            # Require at least 3 different category types for good diversity
-            return len(unique_categories) >= 3
+            # Require at least 2 different category types for good diversity
+            return len(unique_categories) >= 2
+        
+        def calculate_outfit_score(subset: List[int]) -> float:
+            """Calculate overall outfit quality score"""
+            if len(subset) < 2:
+                return 0.0
+                
+            # Base score from category diversity
+            diversity_score = len(set(get_category_type(cat_str(i)) for i in subset)) / 4.0
+            
+            # Style consistency score
+            style_score = calculate_style_consistency_score(subset)
+            
+            # Color consistency score
+            color_score = calculate_color_consistency_score(subset)
+            
+            # Length appropriateness (prefer 3-4 items)
+            length_score = 1.0 if 3 <= len(subset) <= 4 else 0.7
+            
+            # Weighted combination
+            return 0.3 * diversity_score + 0.3 * style_score + 0.2 * color_score + 0.2 * length_score
         
+        # Generate diverse outfit combinations with randomization
         for _ in range(num_samples):
             subset = []
             
-            # EXACT SLOT CONSTRAINTS: Exactly 1 upper, 1 bottom, 1 shoe, ≤2 accessories
-            if uppers and bottoms and shoes:
+            # VARIABLE OUTFIT LENGTH: 2-5 items with different strategies
+            outfit_length = rng.choice([2, 3, 4, 5], p=[0.1, 0.4, 0.4, 0.1])  # Prefer 3-4 items
+            
+            # Strategy 1: Core outfit (shirt + pants + shoes) + accessories
+            if rng.random() < 0.6 and uppers and bottoms and shoes:
                 # Core outfit: exactly 1 of each required slot
                 subset.append(int(rng.choice(uppers)))
                 subset.append(int(rng.choice(bottoms)))
                 subset.append(int(rng.choice(shoes)))
                 
-                # Add accessories based on template limit
-                if accs:
-                    max_accs = template["accessory_limit"]
-                    num_accs = rng.integers(1, min(max_accs + 1, len(accs) + 1))
+                # Add accessories based on template limit and remaining slots
+                remaining_slots = outfit_length - len(subset)
+                if accs and remaining_slots > 0:
+                    max_accs = min(template["accessory_limit"], remaining_slots, len(accs))
+                    num_accs = rng.integers(0, max_accs + 1)
                     available_accs = [i for i in accs if i not in subset]
-                    if available_accs:
+                    if available_accs and num_accs > 0:
                         selected_accs = rng.choice(available_accs, size=min(num_accs, len(available_accs)), replace=False)
                         subset.extend(selected_accs.tolist())
                 
-                # Add 0-1 other items for variety (but not if it would exceed max_size)
-                if others and len(subset) < max_size:
+                # Fill remaining slots with other items
+                remaining_slots = outfit_length - len(subset)
+                if others and remaining_slots > 0:
                     available_others = [i for i in others if i not in subset]
-                    if available_others and rng.random() < 0.3:  # 30% chance to add other item
-                        subset.append(int(rng.choice(available_others)))
-            else:
-                # Fallback: ensure we have at least 3 items with category diversity
-                required_categories = []
-                if uppers: required_categories.append(("upper", uppers))
-                if bottoms: required_categories.append(("bottom", bottoms))
-                if shoes: required_categories.append(("shoe", shoes))
+                    if available_others:
+                        num_others = min(remaining_slots, len(available_others))
+                        selected_others = rng.choice(available_others, size=num_others, replace=False)
+                        subset.extend(selected_others.tolist())
+            
+            # Strategy 2: Flexible combination (no strict slot requirements)
+            elif rng.random() < 0.3:
+                # Randomly select items from all categories
+                all_items = list(ids)
+                rng.shuffle(all_items)
                 
-                # Add one from each available required category
-                for cat_type, cat_items in required_categories:
-                    subset.append(int(rng.choice(cat_items)))
+                # Select items ensuring diversity
+                selected_categories = set()
+                for item in all_items:
+                    if len(subset) >= outfit_length:
+                        break
+                    item_category = get_category_type(cat_str(item))
+                    if item_category not in selected_categories or len(subset) < 2:
+                        subset.append(item)
+                        selected_categories.add(item_category)
+            
+            # Strategy 3: Accessory-focused outfit (for small wardrobes)
+            else:
+                # Start with accessories if available
+                if accs:
+                    num_accs = min(outfit_length, len(accs))
+                    selected_accs = rng.choice(accs, size=num_accs, replace=False)
+                    subset.extend(selected_accs.tolist())
                 
-                # Add accessories if available
-                if accs and len(subset) < max_size:
-                    num_accs = rng.integers(1, min(3, len(accs) + 1))
-                    available_accs = [i for i in accs if i not in subset]
-                    if available_accs:
-                        selected_accs = rng.choice(available_accs, size=min(num_accs, len(available_accs)), replace=False)
-                        subset.extend(selected_accs.tolist())
+                # Fill remaining with other categories
+                remaining_slots = outfit_length - len(subset)
+                if remaining_slots > 0:
+                    other_categories = []
+                    if uppers: other_categories.extend(uppers)
+                    if bottoms: other_categories.extend(bottoms)
+                    if shoes: other_categories.extend(shoes)
+                    if others: other_categories.extend(others)
+                    
+                    available_others = [i for i in other_categories if i not in subset]
+                    if available_others:
+                        num_others = min(remaining_slots, len(available_others))
+                        selected_others = rng.choice(available_others, size=num_others, replace=False)
+                        subset.extend(selected_others.tolist())
             
             # Remove duplicates and validate
             subset = list(set(subset))
-            if len(subset) >= 3:  # At least 3 items for a valid outfit
+            if len(subset) >= 2 and len(subset) <= max_size and has_category_diversity(subset):
+                # Add randomization factor to prevent identical recommendations
+                subset = rng.permutation(subset).tolist()  # Randomize order
                 candidates.append(subset)
                 if len(candidates) % 10 == 0:  # Log every 10 candidates
                     print(f"🔍 DEBUG: Generated {len(candidates)} candidates so far...")
 
         print(f"🔍 DEBUG: Generated {len(candidates)} total candidates")
-        
+
         # 3) Score using ViT
         def score_subset(idx_subset: List[int]) -> float:
             embs = torch.tensor(
@@ -628,26 +695,28 @@ class InferenceService:
 
         # Enhanced validation with strict slot constraints
         def is_valid_outfit(subset: List[int]) -> bool:
-            """Check if outfit meets exact slot requirements"""
+            """Check if outfit meets flexible requirements"""
+            if len(subset) < 2 or len(subset) > max_size:
+                return False
+                
             categories = [get_category_type(cat_str(i)) for i in subset]
             category_counts = {}
             
             for cat in categories:
                 category_counts[cat] = category_counts.get(cat, 0) + 1
             
-            # STRICT VALIDATION:
-            # - Exactly 1 upper, 1 bottom, 1 shoe
-            # - ≤2 accessories
-            # - No other duplicates
-            if category_counts.get("upper", 0) != 1:
+            # FLEXIBLE VALIDATION:
+            # - At least 2 different categories
+            # - Reasonable limits per category
+            # - Allow variable outfit lengths
+            unique_categories = len(set(categories))
+            if unique_categories < 2:
                 return False
-            if category_counts.get("bottom", 0) != 1:
-                return False
-            if category_counts.get("shoe", 0) != 1:
-                return False
-            if category_counts.get("accessory", 0) > 2:
+            
+            # Reasonable limits (more flexible than before)
+            if category_counts.get("accessory", 0) > 3:  # Allow up to 3 accessories
                 return False
-            if category_counts.get("other", 0) > 1:
+            if category_counts.get("other", 0) > 2:  # Allow up to 2 other items
                 return False
             
             return True
@@ -714,9 +783,19 @@ class InferenceService:
             adjusted_score = calculate_outfit_penalty(subset, base_score)
             scored.append((subset, adjusted_score, base_score))
         
-        # Sort by penalty-adjusted score
+        # Sort by penalty-adjusted score with randomization
         scored.sort(key=lambda x: x[1], reverse=True)
-        topk = scored[:num_outfits]
+        
+        # Add randomization to prevent identical recommendations
+        if len(scored) > num_outfits:
+            # Take top 50% and randomly sample from them
+            top_half = scored[:max(num_outfits * 2, len(scored) // 2)]
+            rng.shuffle(top_half)
+            topk = top_half[:num_outfits]
+        else:
+            # If we have fewer candidates than requested, shuffle them
+            rng.shuffle(scored)
+            topk = scored[:num_outfits]
         
         results = []
         for subset, adjusted_score, base_score in topk: