I promise, these are the last changes

inference.py

@@ -386,42 +386,113 @@ class InferenceService:
         print("🔍 DEBUG: Starting candidate generation...")
 
         # 2) Candidate generation with outfit templates
-        rng = np.random.default_rng(int(context.get("seed", 42)))
+        # Use timestamp-based seed for better randomization
+        import time
+        seed = context.get("seed", int(time.time() * 1000) % 10000)
+        rng = np.random.default_rng(seed)
+        print(f"🔍 DEBUG: Using random seed: {seed}")
         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
+        # Enhanced context-aware outfit templates
         outfit_templates = {
             "casual": {
                 "style": "relaxed, comfortable, everyday",
-                "preferred_categories": ["tshirt", "jean", "sneaker", "hoodie", "sweatpant"],
+                "preferred_categories": ["tshirt", "jean", "sneaker", "hoodie", "sweatpant", "shirt", "pants", "shoes"],
                 "color_palette": ["neutral", "denim", "white", "black", "gray"],
-                "accessory_limit": 2
+                "accessory_limit": 2,
+                "weather_modifiers": {
+                    "hot": {"preferred_categories": ["tank", "short", "sandal", "light shirt"]},
+                    "cold": {"preferred_categories": ["hoodie", "sweater", "jacket", "boot"]},
+                    "rain": {"preferred_categories": ["jacket", "boot", "waterproof"]}
+                },
+                "occasion_modifiers": {
+                    "business": {"preferred_categories": ["shirt", "pants", "shoes"], "accessory_limit": 3},
+                    "formal": {"preferred_categories": ["shirt", "pants", "shoes"], "accessory_limit": 4}
+                }
             },
             "smart_casual": {
                 "style": "polished but relaxed, business casual",
-                "preferred_categories": ["shirt", "chino", "loafer", "blazer", "polo"],
+                "preferred_categories": ["shirt", "chino", "loafer", "blazer", "polo", "pants", "shoes"],
                 "color_palette": ["navy", "white", "khaki", "brown", "gray"],
-                "accessory_limit": 3
+                "accessory_limit": 3,
+                "weather_modifiers": {
+                    "hot": {"preferred_categories": ["polo", "light shirt", "loafer"]},
+                    "cold": {"preferred_categories": ["blazer", "sweater", "boot"]},
+                    "rain": {"preferred_categories": ["blazer", "boot", "umbrella"]}
+                },
+                "occasion_modifiers": {
+                    "business": {"preferred_categories": ["shirt", "pants", "shoes"], "accessory_limit": 4},
+                    "formal": {"preferred_categories": ["shirt", "pants", "shoes"], "accessory_limit": 4}
+                }
             },
             "formal": {
                 "style": "professional, elegant, sophisticated",
-                "preferred_categories": ["blazer", "dress shirt", "dress pant", "oxford", "suit"],
+                "preferred_categories": ["blazer", "dress shirt", "dress pant", "oxford", "suit", "shirt", "pants", "shoes"],
                 "color_palette": ["navy", "black", "white", "gray", "charcoal"],
-                "accessory_limit": 4
+                "accessory_limit": 4,
+                "weather_modifiers": {
+                    "hot": {"preferred_categories": ["light shirt", "light pant", "oxford"]},
+                    "cold": {"preferred_categories": ["blazer", "suit", "boot"]},
+                    "rain": {"preferred_categories": ["blazer", "boot", "umbrella"]}
+                },
+                "occasion_modifiers": {
+                    "business": {"preferred_categories": ["shirt", "pants", "shoes"], "accessory_limit": 4},
+                    "casual": {"preferred_categories": ["shirt", "pants", "shoes"], "accessory_limit": 3}
+                }
             },
             "sporty": {
                 "style": "athletic, active, performance",
-                "preferred_categories": ["athletic shirt", "jogger", "running shoe", "tank", "legging"],
+                "preferred_categories": ["athletic shirt", "jogger", "running shoe", "tank", "legging", "shirt", "pants", "shoes"],
                 "color_palette": ["bright", "neon", "white", "black", "primary colors"],
-                "accessory_limit": 1
+                "accessory_limit": 1,
+                "weather_modifiers": {
+                    "hot": {"preferred_categories": ["tank", "short", "running shoe"]},
+                    "cold": {"preferred_categories": ["hoodie", "legging", "running shoe"]},
+                    "rain": {"preferred_categories": ["jacket", "running shoe", "cap"]}
+                },
+                "occasion_modifiers": {
+                    "business": {"preferred_categories": ["shirt", "pants", "shoes"], "accessory_limit": 2},
+                    "formal": {"preferred_categories": ["shirt", "pants", "shoes"], "accessory_limit": 3}
+                }
             }
         }
         
-        # Select outfit template (can be passed in context or randomly selected)
-        template_name = context.get("outfit_style", rng.choice(list(outfit_templates.keys())))
-        template = outfit_templates[template_name]
+        # Context-aware template selection and modification
+        occasion = context.get("occasion", "casual")
+        weather = context.get("weather", "any")
+        outfit_style = context.get("outfit_style", "casual")
+        
+        # Select base template
+        template_name = outfit_style
+        template = outfit_templates[template_name].copy()
+        
+        # Apply weather modifications
+        if weather != "any" and weather in template.get("weather_modifiers", {}):
+            weather_mod = template["weather_modifiers"][weather]
+            template["preferred_categories"].extend(weather_mod.get("preferred_categories", []))
+            if "accessory_limit" in weather_mod:
+                template["accessory_limit"] = weather_mod["accessory_limit"]
+        
+        # Apply occasion modifications
+        if occasion in template.get("occasion_modifiers", {}):
+            occasion_mod = template["occasion_modifiers"][occasion]
+            template["preferred_categories"].extend(occasion_mod.get("preferred_categories", []))
+            if "accessory_limit" in occasion_mod:
+                template["accessory_limit"] = occasion_mod["accessory_limit"]
+        
+        # Remove duplicates and add context info
+        template["preferred_categories"] = list(set(template["preferred_categories"]))
+        template["context"] = {
+            "occasion": occasion,
+            "weather": weather,
+            "style": outfit_style
+        }
+        
+        print(f"🔍 DEBUG: Using template '{template_name}' with context: occasion={occasion}, weather={weather}")
+        print(f"🔍 DEBUG: Template categories: {template['preferred_categories']}")
+        print(f"🔍 DEBUG: Accessory limit: {template['accessory_limit']}")
 
         # Enhanced category-aware pools with diversity checks
         def cat_str(i: int) -> str:
@@ -483,7 +554,30 @@ class InferenceService:
                 if any(pref in cat for pref in preferred_cats):
                     matches += 1
             
-            return matches / len(categories) if categories else 0.0
+            base_score = matches / len(categories) if categories else 0.0
+            
+            # Bonus for context-specific categories
+            context_bonus = 0.0
+            occasion = template["context"]["occasion"]
+            weather = template["context"]["weather"]
+            
+            # Occasion-specific bonuses
+            if occasion == "business" and any("shirt" in cat or "pants" in cat for cat in categories):
+                context_bonus += 0.2
+            elif occasion == "formal" and any("shirt" in cat or "pants" in cat for cat in categories):
+                context_bonus += 0.3
+            elif occasion == "sport" and any("shirt" in cat or "pants" in cat for cat in categories):
+                context_bonus += 0.2
+            
+            # Weather-specific bonuses
+            if weather == "hot" and any("shirt" in cat for cat in categories):
+                context_bonus += 0.1
+            elif weather == "cold" and any("shirt" in cat or "pants" in cat for cat in categories):
+                context_bonus += 0.1
+            elif weather == "rain" and any("shoes" in cat for cat in categories):
+                context_bonus += 0.1
+            
+            return min(1.0, base_score + context_bonus)
 
         def get_category_type(cat: str) -> str:
             """Map category to outfit slot type with comprehensive taxonomy"""
@@ -599,15 +693,32 @@ class InferenceService:
             # 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
+        # Context-aware candidate generation with enhanced randomization
         for _ in range(num_samples):
             subset = []
             
-            # 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
+            # Context-aware outfit length selection
+            occasion = template["context"]["occasion"]
+            if occasion == "formal":
+                outfit_length = rng.choice([3, 4, 5], p=[0.2, 0.5, 0.3])  # Formal outfits tend to be more complete
+            elif occasion == "business":
+                outfit_length = rng.choice([3, 4, 5], p=[0.3, 0.5, 0.2])  # Business outfits are well-rounded
+            elif occasion == "sport":
+                outfit_length = rng.choice([2, 3, 4], p=[0.3, 0.5, 0.2])  # Sport outfits can be minimal
+            else:  # casual
+                outfit_length = rng.choice([2, 3, 4, 5], p=[0.2, 0.4, 0.3, 0.1])  # Casual is flexible
+            
+            # Context-aware strategy selection
+            strategy_weights = [0.4, 0.3, 0.3]  # Default weights
+            if occasion == "formal":
+                strategy_weights = [0.6, 0.2, 0.2]  # Favor core outfits for formal
+            elif occasion == "sport":
+                strategy_weights = [0.3, 0.5, 0.2]  # Favor flexible combinations for sport
+            
+            strategy = rng.choice([0, 1, 2], p=strategy_weights)
             
             # Strategy 1: Core outfit (shirt + pants + shoes) + accessories
-            if rng.random() < 0.5 and uppers and bottoms and shoes:
+            if strategy == 0 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)))
@@ -634,7 +745,7 @@ class InferenceService:
                         subset.extend(selected_others.tolist())
             
             # Strategy 2: Accessory-focused outfit (prioritize accessories)
-            elif rng.random() < 0.3 and accs:
+            elif strategy == 1 and accs:
                 # Start with accessories if available
                 num_accs = min(outfit_length, len(accs))
                 selected_accs = rng.choice(accs, size=num_accs, replace=False)
@@ -656,7 +767,7 @@ class InferenceService:
                         subset.extend(selected_others.tolist())
             
             # Strategy 3: Flexible combination (no strict slot requirements)
-            else:
+            elif strategy == 2:
                 # Randomly select items from all categories
                 all_items = list(ids)
                 rng.shuffle(all_items)
@@ -807,16 +918,33 @@ class InferenceService:
         print(f"🔍 DEBUG: Removed {len(scored) - len(unique_scored)} duplicate outfits")
         scored = unique_scored
         
-        # Add randomization to prevent identical recommendations
+        # Enhanced randomization with context awareness
         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]
+            # Context-aware selection: prefer higher-scoring outfits but add diversity
+            top_third = scored[:max(num_outfits * 3, len(scored) // 3)]
+            middle_third = scored[max(num_outfits * 3, len(scored) // 3):max(num_outfits * 6, len(scored) * 2 // 3)]
+            
+            # Select mix of high-scoring and diverse outfits
+            selected = []
+            
+            # Take 70% from top third (high quality)
+            top_count = int(num_outfits * 0.7)
+            rng.shuffle(top_third)
+            selected.extend(top_third[:top_count])
+            
+            # Take 30% from middle third (diversity)
+            middle_count = num_outfits - len(selected)
+            if middle_count > 0 and middle_third:
+                rng.shuffle(middle_third)
+                selected.extend(middle_third[:middle_count])
+            
+            # Shuffle final selection for randomness
+            rng.shuffle(selected)
+            topk = selected[:num_outfits]
         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: