last changes final deployment, hopefully

inference.py

@@ -387,8 +387,8 @@ class InferenceService:
 
         # 2) Candidate generation with outfit templates
         rng = np.random.default_rng(int(context.get("seed", 42)))
-        num_outfits = int(context.get("num_outfits", 3))
-        min_size, max_size = 4, 6
+        num_outfits = int(context.get("num_outfits", 5))  # Increased default from 3 to 5
+        min_size, max_size = 2, 6  # Allow smaller outfits (2 items minimum)
         ids = list(range(len(proc_items)))
 
         # Outfit templates for cohesive styling
@@ -569,7 +569,7 @@ class InferenceService:
             print(f"🔍 DEBUG: Will use flexible outfit generation with available items")
 
         candidates: List[List[int]] = []
-        num_samples = max(num_outfits * 15, 30)  # Increased for more variety
+        num_samples = max(num_outfits * 25, 50)  # Further increased for more variety
         print(f"🔍 DEBUG: Generating {num_samples} candidate outfits...")
         
         def has_category_diversity(subset: List[int]) -> bool:
@@ -607,17 +607,18 @@ class InferenceService:
             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:
+            if rng.random() < 0.5 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 and remaining slots
+                # Prioritize accessories - higher chance of including them
                 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)
+                    # Higher probability of including accessories
+                    num_accs = rng.integers(1, max_accs + 1) if rng.random() < 0.8 else 0
                     available_accs = [i for i in accs if i not in subset]
                     if available_accs and num_accs > 0:
                         selected_accs = rng.choice(available_accs, size=min(num_accs, len(available_accs)), replace=False)
@@ -632,29 +633,12 @@ class InferenceService:
                         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)
-                
-                # 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:
+            # Strategy 2: Accessory-focused outfit (prioritize accessories)
+            elif rng.random() < 0.3 and accs:
                 # 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())
+                num_accs = min(outfit_length, len(accs))
+                selected_accs = rng.choice(accs, size=num_accs, replace=False)
+                subset.extend(selected_accs.tolist())
                 
                 # Fill remaining with other categories
                 remaining_slots = outfit_length - len(subset)
@@ -671,6 +655,22 @@ class InferenceService:
                         selected_others = rng.choice(available_others, size=num_others, replace=False)
                         subset.extend(selected_others.tolist())
             
+            # Strategy 3: Flexible combination (no strict slot requirements)
+            else:
+                # Randomly select items from all categories
+                all_items = list(ids)
+                rng.shuffle(all_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)
+            
             # Remove duplicates and validate
             subset = list(set(subset))
             if len(subset) >= 2 and len(subset) <= max_size and has_category_diversity(subset):
@@ -768,6 +768,11 @@ class InferenceService:
             if style_score > 0.6:  # Good style match
                 bonus += 0.2
             
+            # Accessory inclusion bonus
+            categories = [get_category_type(cat_str(i)) for i in subset]
+            if "accessory" in categories:
+                bonus += 0.3  # Bonus for including accessories
+            
             return base_score + penalty + bonus
         
         # Score and filter valid outfits with penalty adjustment
@@ -786,6 +791,22 @@ class InferenceService:
         # Sort by penalty-adjusted score with randomization
         scored.sort(key=lambda x: x[1], reverse=True)
         
+        # Remove duplicate outfits (same items, different order)
+        def normalize_outfit(subset):
+            """Normalize outfit by sorting item IDs for duplicate detection"""
+            return tuple(sorted(subset))
+        
+        seen_outfits = set()
+        unique_scored = []
+        for subset, adjusted_score, base_score in scored:
+            normalized = normalize_outfit(subset)
+            if normalized not in seen_outfits:
+                seen_outfits.add(normalized)
+                unique_scored.append((subset, adjusted_score, base_score))
+        
+        print(f"🔍 DEBUG: Removed {len(scored) - len(unique_scored)} duplicate outfits")
+        scored = unique_scored
+        
         # Add randomization to prevent identical recommendations
         if len(scored) > num_outfits:
             # Take top 50% and randomly sample from them
@@ -795,7 +816,7 @@ class InferenceService:
         else:
             # If we have fewer candidates than requested, shuffle them
             rng.shuffle(scored)
-            topk = scored[:num_outfits]
+        topk = scored[:num_outfits]
         
         results = []
         for subset, adjusted_score, base_score in topk: