Final fixes 5666444

app.py

@@ -296,6 +296,43 @@ threading.Thread(target=_background_bootstrap, daemon=True).start()
 def health() -> dict:
     return {"status": "ok", "device": service.device, "resnet": service.resnet_version, "vit": service.vit_version}
 
+@app.get("/model-status")
+def model_status() -> dict:
+    """Get detailed model loading status."""
+    return service.get_model_status()
+
+@app.post("/reload-models")
+def reload_models() -> dict:
+    """Force reload models - useful for debugging."""
+    try:
+        service.force_reload_models()
+        return {"status": "success", "message": "Models reloaded successfully"}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+@app.post("/test-recommend")
+def test_recommend() -> dict:
+    """Test recommendation with dummy data to debug the issue."""
+    try:
+        # Create dummy items for testing
+        dummy_items = [
+            {"id": "test_1", "image": None, "category": "shirt"},
+            {"id": "test_2", "image": None, "category": "pants"},
+            {"id": "test_3", "image": None, "category": "shoes"}
+        ]
+        
+        # Try to get recommendations
+        result = service.compose_outfits(dummy_items, {"num_outfits": 1})
+        
+        return {
+            "status": "success",
+            "model_status": service.get_model_status(),
+            "result": result,
+            "result_length": len(result) if result else 0
+        }
+    except Exception as e:
+        return {"status": "error", "message": str(e), "model_status": service.get_model_status()}
+
 
 @app.post("/embed")
 def embed(req: EmbedRequest, x_api_key: Optional[str] = Header(None)) -> dict:

inference.py

@@ -45,8 +45,8 @@ class InferenceService:
         # Disable gradients
         for m in [self.resnet, self.vit]:
             if m is not None:
-                for p in m.parameters():
-                    p.requires_grad_(False)
+            for p in m.parameters():
+                p.requires_grad_(False)
 
         # Update overall status
         self.models_loaded = self.resnet_loaded and self.vit_loaded
@@ -177,8 +177,8 @@ class InferenceService:
         # Disable gradients
         for m in [self.resnet, self.vit]:
             if m is not None:
-                for p in m.parameters():
-                    p.requires_grad_(False)
+            for p in m.parameters():
+                p.requires_grad_(False)
         
         # Update overall status
         self.models_loaded = self.resnet_loaded and self.vit_loaded
@@ -202,12 +202,12 @@ class InferenceService:
             return []
             
         try:
-            batch = torch.stack([self.transform(img) for img in images])
-            batch = batch.to(self.device, memory_format=torch.channels_last)
-            use_amp = (self.device == "cuda")
-            with torch.autocast(device_type=("cuda" if use_amp else "cpu"), enabled=use_amp):
-                emb = self.resnet(batch)
-            emb = nn.functional.normalize(emb, dim=-1)
+        batch = torch.stack([self.transform(img) for img in images])
+        batch = batch.to(self.device, memory_format=torch.channels_last)
+        use_amp = (self.device == "cuda")
+        with torch.autocast(device_type=("cuda" if use_amp else "cpu"), enabled=use_amp):
+            emb = self.resnet(batch)
+        emb = nn.functional.normalize(emb, dim=-1)
             result = [e.detach().cpu().numpy().astype(np.float32) for e in emb]
             print(f"🔍 DEBUG: Successfully generated {len(result)} embeddings")
             return result
@@ -257,6 +257,8 @@ 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
         rng = np.random.default_rng(int(context.get("seed", 42)))
@@ -299,6 +301,11 @@ 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)):
+            print(f"🔍 DEBUG: Item {i}: category='{proc_items[i].get('category')}' -> cat_str='{cat_str(i)}'")
 
         def extract_color_from_category(category: str) -> str:
             """Extract color information from category name"""
@@ -356,6 +363,7 @@ class InferenceService:
         def get_category_type(cat: str) -> str:
             """Map category to outfit slot type with comprehensive taxonomy"""
             cat_lower = cat.lower().strip()
+            print(f"🔍 DEBUG: Mapping category '{cat}' -> '{cat_lower}'")
             
             # Upper body items (tops, outerwear)
             upper_keywords = [
@@ -405,14 +413,23 @@ class InferenceService:
                 return "other"
 
         # Create category pools
+        print("🔍 DEBUG: Building category pools...")
         uppers = [i for i in ids if get_category_type(cat_str(i)) == "upper"]
         bottoms = [i for i in ids if get_category_type(cat_str(i)) == "bottom"]
         shoes = [i for i in ids if get_category_type(cat_str(i)) == "shoe"]
         accs = [i for i in ids if get_category_type(cat_str(i)) == "accessory"]
         others = [i for i in ids if get_category_type(cat_str(i)) == "other"]
+        
+        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)}")
+            return []
 
         candidates: List[List[int]] = []
         num_samples = max(num_outfits * 12, 24)
+        print(f"🔍 DEBUG: Generating {num_samples} candidate outfits...")
         
         def has_category_diversity(subset: List[int]) -> bool:
             """Check if subset has good category diversity"""
@@ -468,7 +485,11 @@ class InferenceService:
             subset = list(set(subset))
             if len(subset) >= 3:  # At least 3 items for a valid outfit
                 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(
@@ -609,7 +630,7 @@ class InferenceService:
             })
         
         return results
-    
+
     def get_model_status(self) -> Dict[str, Any]:
         """Get current model loading status and errors."""
         return {
@@ -617,7 +638,38 @@ class InferenceService:
             "resnet_loaded": self.resnet_loaded,
             "vit_loaded": self.vit_loaded,
             "errors": self.model_errors,
-            "can_recommend": self.models_loaded
+            "can_recommend": self.models_loaded,
+            "resnet_model": self.resnet is not None,
+            "vit_model": self.vit is not None
         }
+    
+    def force_reload_models(self) -> None:
+        """Force reload models and update status - useful for debugging."""
+        print("🔄 Force reloading models...")
+        self.resnet, self.resnet_loaded = self._load_resnet()
+        self.vit, self.vit_loaded = self._load_vit()
+        
+        # Move to device and set eval mode
+        if self.resnet_loaded:
+            self.resnet = self.resnet.to(self.device).eval()
+        if self.vit_loaded:
+            self.vit = self.vit.to(self.device).eval()
+            
+        # Disable gradients
+        for m in [self.resnet, self.vit]:
+            if m is not None:
+                for p in m.parameters():
+                    p.requires_grad_(False)
+        
+        # Update overall status
+        self.models_loaded = self.resnet_loaded and self.vit_loaded
+        print(f"🔄 Models reloaded: resnet={self.resnet_loaded}, vit={self.vit_loaded}, overall={self.models_loaded}")
+        
+        if not self.models_loaded:
+            self.model_errors = []
+            if not self.resnet_loaded:
+                self.model_errors.append("ResNet: No trained weights found")
+            if not self.vit_loaded:
+                self.model_errors.append("ViT: No trained weights found")