nee last fixes

inference.py

@@ -551,28 +551,62 @@ class InferenceService:
             return "unknown"
         
         def calculate_color_consistency_score(items: List[int]) -> float:
-            """Calculate color consistency score for outfit items"""
+            """Calculate sophisticated color harmony score using fashion theory"""
             colors = [extract_color_from_category(cat_str(i)) for i in items]
             color_counts = {}
             for color in colors:
                 color_counts[color] = color_counts.get(color, 0) + 1
             
-            # Prefer outfits with 2-3 dominant colors
-            dominant_colors = [c for c, count in color_counts.items() if count >= 2]
-            if len(dominant_colors) == 0:
-                return 0.5  # Neutral score for all different colors
-            elif len(dominant_colors) == 1:
-                return 0.8  # Good consistency
-            elif len(dominant_colors) == 2:
-                return 1.0  # Perfect balance
-            else:
-                return 0.3  # Too many dominant colors
+            # Advanced color harmony rules
+            base_score = 0.0
+            
+            # 1. Monochromatic harmony (same color family)
+            dominant_color = max(color_counts.items(), key=lambda x: x[1])[0] if color_counts else "unknown"
+            if color_counts.get(dominant_color, 0) >= 2:
+                base_score += 0.4  # Strong monochromatic bonus
+            
+            # 2. Complementary color harmony
+            complementary_pairs = [
+                ("black", "white"), ("navy", "white"), ("brown", "beige"),
+                ("red", "green"), ("blue", "orange"), ("purple", "yellow")
+            ]
+            for color1, color2 in complementary_pairs:
+                if color_counts.get(color1, 0) > 0 and color_counts.get(color2, 0) > 0:
+                    base_score += 0.3  # Complementary harmony bonus
+                    break
+            
+            # 3. Neutral base with accent colors
+            neutral_colors = ["black", "white", "gray", "navy", "brown", "beige"]
+            neutral_count = sum(color_counts.get(c, 0) for c in neutral_colors)
+            if neutral_count >= 2 and len([c for c in colors if c not in neutral_colors]) <= 1:
+                base_score += 0.2  # Neutral base bonus
+            
+            # 4. Color distribution penalty
+            if len(color_counts) > 4:
+                base_score -= 0.2  # Too many different colors
+            elif len(color_counts) == 1 and len(items) > 2:
+                base_score -= 0.1  # Too monotonous
+            
+            # 5. Context-aware color scoring
+            if occasion == "formal":
+                formal_colors = ["black", "navy", "white", "gray", "charcoal"]
+                formal_count = sum(color_counts.get(c, 0) for c in formal_colors)
+                if formal_count >= 2:
+                    base_score += 0.2  # Formal color bonus
+            elif occasion == "business":
+                business_colors = ["navy", "white", "gray", "black", "brown"]
+                business_count = sum(color_counts.get(c, 0) for c in business_colors)
+                if business_count >= 2:
+                    base_score += 0.15  # Business color bonus
+            
+            return min(1.0, max(0.0, base_score + 0.3))  # Ensure score is between 0-1
             
         def calculate_style_consistency_score(items: List[int]) -> float:
-            """Calculate style consistency based on template preferences"""
+            """Calculate advanced style consistency using fashion expert rules"""
             categories = [cat_str(i) for i in items]
             preferred_cats = template["preferred_categories"]
             
+            # Base template matching
             matches = 0
             for cat in categories:
                 if any(pref in cat for pref in preferred_cats):
@@ -580,28 +614,97 @@ class InferenceService:
             
             base_score = matches / len(categories) if categories else 0.0
             
-            # Bonus for context-specific categories
-            context_bonus = 0.0
+            # Advanced fashion rules scoring
+            fashion_bonus = 0.0
             occasion = template["context"]["occasion"]
             weather = template["context"]["weather"]
+            outfit_style = template["context"]["style"]
             
-            # 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)
+            # 1. Occasion-appropriate style rules
+            if occasion == "formal":
+                # Formal requires structured, tailored pieces
+                formal_items = ["jacket", "blazer", "suit", "dress shirt", "dress pant", "oxford"]
+                formal_count = sum(1 for cat in categories if any(f in cat for f in formal_items))
+                if formal_count >= 3:  # At least 3 formal items
+                    fashion_bonus += 0.4
+                elif formal_count >= 2:
+                    fashion_bonus += 0.2
+                    
+            elif occasion == "business":
+                # Business requires professional but not overly formal
+                business_items = ["shirt", "blazer", "pants", "loafer", "oxford", "dress pant"]
+                business_count = sum(1 for cat in categories if any(b in cat for b in business_items))
+                if business_count >= 3:
+                    fashion_bonus += 0.3
+                elif business_count >= 2:
+                    fashion_bonus += 0.15
+                    
+            elif occasion == "sport":
+                # Sport requires athletic, functional pieces
+                sport_items = ["athletic", "running", "jogger", "sneaker", "tank", "legging"]
+                sport_count = sum(1 for cat in categories if any(s in cat for s in sport_items))
+                if sport_count >= 2:
+                    fashion_bonus += 0.3
+                    
+            # 2. Style coherence rules
+            if outfit_style == "formal":
+                # Formal style coherence
+                if "jacket" in categories and "shirt" in categories:
+                    fashion_bonus += 0.2  # Proper layering
+                if len([c for c in categories if c in ["jacket", "shirt", "pants", "shoes"]]) >= 3:
+                    fashion_bonus += 0.2  # Complete formal set
+                    
+            elif outfit_style == "smart_casual":
+                # Smart casual balance
+                if "shirt" in categories and "pants" in categories:
+                    fashion_bonus += 0.15
+                if "blazer" in categories or "jacket" in categories:
+                    fashion_bonus += 0.1  # Elevated casual
+                    
+            elif outfit_style == "traditional":
+                # Traditional Pakistani coherence
+                traditional_items = ["kameez", "kurta", "shalwar", "peshawari", "chappal"]
+                traditional_count = sum(1 for cat in categories if any(t in cat for t in traditional_items))
+                if traditional_count >= 2:
+                    fashion_bonus += 0.4
+                if traditional_count == 3:  # Complete traditional set
+                    fashion_bonus += 0.2
+            
+            # 3. Weather-appropriate logic
+            if weather == "hot":
+                # Hot weather preferences
+                if any("light" in cat or "cotton" in cat or "tank" in cat for cat in categories):
+                    fashion_bonus += 0.1
+                if "jacket" in categories and len(categories) > 3:
+                    fashion_bonus -= 0.1  # Too many layers for hot weather
+                    
+            elif weather == "cold":
+                # Cold weather preferences
+                if "jacket" in categories or "blazer" in categories:
+                    fashion_bonus += 0.15
+                if "sweater" in categories or "hoodie" in categories:
+                    fashion_bonus += 0.1
+                    
+            elif weather == "rain":
+                # Rain weather preferences
+                if any("waterproof" in cat or "boot" in cat for cat in categories):
+                    fashion_bonus += 0.2
+                if "jacket" in categories:
+                    fashion_bonus += 0.1
+            
+            # 4. Proportions and balance
+            category_types = [get_category_type(cat) for cat in categories]
+            type_counts = {}
+            for cat_type in category_types:
+                type_counts[cat_type] = type_counts.get(cat_type, 0) + 1
+            
+            # Balanced outfit proportions
+            if len(type_counts) >= 3:  # Good diversity
+                fashion_bonus += 0.1
+            if type_counts.get("accessory", 0) <= 2:  # Not over-accessorized
+                fashion_bonus += 0.05
+            
+            return min(1.0, base_score + fashion_bonus)
 
         def get_category_type(cat: str) -> str:
             """Map category to outfit slot type with comprehensive taxonomy"""
@@ -716,46 +819,140 @@ class InferenceService:
             return len(unique_categories) >= 2
         
         def calculate_outfit_score(subset: List[int]) -> float:
-            """Calculate overall outfit quality score"""
+            """Calculate sophisticated outfit quality score using advanced fashion reasoning"""
             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
+            # 1. Category diversity and completeness
+            category_types = [get_category_type(cat_str(i)) for i in subset]
+            unique_types = set(category_types)
+            diversity_score = len(unique_types) / 5.0  # Normalize to 5 categories max
+            
+            # Completeness bonus for essential categories
+            essential_categories = {"upper", "bottom", "shoe"}
+            completeness_bonus = 0.0
+            if essential_categories.issubset(unique_types):
+                completeness_bonus += 0.3  # All essential categories present
+            elif len(essential_categories.intersection(unique_types)) >= 2:
+                completeness_bonus += 0.15  # Most essential categories present
+            
+            # 2. Advanced style consistency
             style_score = calculate_style_consistency_score(subset)
             
-            # Color consistency score
+            # 3. Sophisticated color harmony
             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
+            # 4. Context-appropriate length scoring
+            occasion = template["context"]["occasion"]
+            if occasion == "formal":
+                length_score = 1.0 if 4 <= len(subset) <= 5 else 0.6  # Formal prefers complete sets
+            elif occasion == "business":
+                length_score = 1.0 if 3 <= len(subset) <= 4 else 0.7  # Business balanced
+            elif occasion == "sport":
+                length_score = 1.0 if 2 <= len(subset) <= 3 else 0.8  # Sport can be minimal
+            else:  # casual
+                length_score = 1.0 if 2 <= len(subset) <= 4 else 0.7  # Casual flexible
+            
+            # 5. Fashion rule compliance
+            fashion_rules_score = 0.0
             
-            # Weighted combination
-            return 0.3 * diversity_score + 0.3 * style_score + 0.2 * color_score + 0.2 * length_score
+            # Rule: No more than one item per core category (except accessories)
+            core_categories = {"upper", "bottom", "shoe", "outerwear"}
+            core_counts = {cat: category_types.count(cat) for cat in core_categories}
+            if all(count <= 1 for count in core_counts.values()):
+                fashion_rules_score += 0.2  # Perfect core category distribution
+            
+            # Rule: Appropriate accessory count
+            accessory_count = category_types.count("accessory")
+            max_accessories = template.get("accessory_limit", 3)
+            if accessory_count <= max_accessories:
+                fashion_rules_score += 0.1
+            if accessory_count > 0 and accessory_count <= 2:
+                fashion_rules_score += 0.1  # Bonus for tasteful accessorizing
+            
+            # Rule: Occasion-appropriate formality
+            if occasion == "formal" and "outerwear" in unique_types:
+                fashion_rules_score += 0.2  # Formal requires outerwear
+            elif occasion == "business" and len(unique_types) >= 3:
+                fashion_rules_score += 0.15  # Business requires completeness
+            elif occasion == "sport" and any("athletic" in cat_str(i) for i in subset):
+                fashion_rules_score += 0.1  # Sport requires athletic items
+            
+            # 6. Advanced weighted combination with reasoning
+            base_score = (
+                0.25 * (diversity_score + completeness_bonus) +  # Structure and completeness
+                0.30 * style_score +                            # Style coherence
+                0.20 * color_score +                            # Color harmony
+                0.15 * length_score +                           # Appropriate length
+                0.10 * fashion_rules_score                      # Fashion rule compliance
+            )
+            
+            # 7. Context-specific adjustments
+            context_adjustment = 0.0
+            
+            # Weather appropriateness
+            weather = template["context"]["weather"]
+            if weather == "hot" and len(subset) > 4:
+                context_adjustment -= 0.1  # Too many layers for hot weather
+            elif weather == "cold" and "outerwear" not in unique_types:
+                context_adjustment -= 0.1  # Missing outerwear for cold weather
+            elif weather == "rain" and not any("boot" in cat_str(i) for i in subset):
+                context_adjustment -= 0.05  # Missing weather-appropriate footwear
+            
+            # Occasion-specific adjustments
+            if occasion == "formal" and len(subset) < 4:
+                context_adjustment -= 0.1  # Formal outfits should be complete
+            elif occasion == "sport" and len(subset) > 4:
+                context_adjustment -= 0.05  # Sport outfits can be simpler
+            
+            return min(1.0, max(0.0, base_score + context_adjustment))
         
-        # Context-aware candidate generation with enhanced randomization
+        # Advanced candidate generation with sophisticated reasoning
         for _ in range(num_samples):
             subset = []
             
-            # Context-aware outfit length selection
+            # 1. Advanced context-aware outfit length selection
             occasion = template["context"]["occasion"]
+            weather = template["context"]["weather"]
+            outfit_style = template["context"]["style"]
+            
+            # Base length probabilities
             if occasion == "formal":
-                outfit_length = rng.choice([3, 4, 5], p=[0.2, 0.5, 0.3])  # Formal outfits tend to be more complete
+                if weather == "hot":
+                    outfit_length = rng.choice([3, 4], p=[0.4, 0.6])  # Formal but weather-appropriate
+                else:
+                    outfit_length = rng.choice([4, 5], p=[0.6, 0.4])  # Complete formal sets
             elif occasion == "business":
-                outfit_length = rng.choice([3, 4, 5], p=[0.3, 0.5, 0.2])  # Business outfits are well-rounded
+                outfit_length = rng.choice([3, 4, 5], p=[0.3, 0.5, 0.2])  # Professional balance
             elif occasion == "sport":
-                outfit_length = rng.choice([2, 3, 4], p=[0.3, 0.5, 0.2])  # Sport outfits can be minimal
+                if weather == "hot":
+                    outfit_length = rng.choice([2, 3], p=[0.6, 0.4])  # Minimal for hot weather
+                else:
+                    outfit_length = rng.choice([2, 3, 4], p=[0.3, 0.5, 0.2])  # Sport flexibility
             else:  # casual
-                outfit_length = rng.choice([2, 3, 4, 5], p=[0.2, 0.4, 0.3, 0.1])  # Casual is flexible
+                if weather == "hot":
+                    outfit_length = rng.choice([2, 3, 4], p=[0.4, 0.4, 0.2])  # Casual, weather-appropriate
+                else:
+                    outfit_length = rng.choice([2, 3, 4, 5], p=[0.2, 0.4, 0.3, 0.1])  # Casual flexibility
             
-            # Context-aware strategy selection
-            strategy_weights = [0.4, 0.3, 0.3]  # Default weights
+            # 2. Advanced strategy selection with reasoning
+            strategy_weights = [0.4, 0.3, 0.3]  # Default: Core, Accessory-focused, Flexible
+            
+            # Formal occasions prioritize complete, structured outfits
             if occasion == "formal":
-                strategy_weights = [0.6, 0.2, 0.2]  # Favor core outfits for formal
+                strategy_weights = [0.7, 0.1, 0.2]  # Strongly favor core outfits
+            # Business occasions need professional balance
+            elif occasion == "business":
+                strategy_weights = [0.6, 0.2, 0.2]  # Favor core with some flexibility
+            # Sport occasions can be more flexible
             elif occasion == "sport":
-                strategy_weights = [0.3, 0.5, 0.2]  # Favor flexible combinations for sport
+                strategy_weights = [0.3, 0.2, 0.5]  # Favor flexible combinations
+            # Traditional outfits need cultural coherence
+            elif outfit_style == "traditional":
+                strategy_weights = [0.8, 0.1, 0.1]  # Strongly favor traditional core sets
+            # Casual occasions allow more creativity
+            else:
+                strategy_weights = [0.4, 0.3, 0.3]  # Balanced approach
             
             strategy = rng.choice([0, 1, 2], p=strategy_weights)
             
@@ -858,9 +1055,9 @@ class InferenceService:
             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...")
+            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")
 
@@ -904,7 +1101,7 @@ class InferenceService:
             return True
         
         def calculate_outfit_penalty(subset: List[int], base_score: float) -> float:
-            """Calculate penalty-adjusted score for outfit quality with style/color bonuses"""
+            """Calculate sophisticated penalty-adjusted score with advanced fashion reasoning"""
             categories = [get_category_type(cat_str(i)) for i in subset]
             category_counts = {}
             
@@ -914,7 +1111,8 @@ class InferenceService:
             penalty = 0.0
             bonus = 0.0
             
-            # Missing core slots: -∞ penalty
+            # 1. Critical fashion violations (severe penalties)
+            # Missing essential categories: -∞ penalty
             if category_counts.get("upper", 0) == 0:
                 penalty += -1000.0
             if category_counts.get("bottom", 0) == 0:
@@ -922,54 +1120,110 @@ class InferenceService:
             if category_counts.get("shoe", 0) == 0:
                 penalty += -1000.0
             
-            # Special penalty for formal outfits missing outerwear
+            # Duplicate core categories: -∞ penalty (fashion rule violation)
+            core_categories = {"upper", "bottom", "shoe", "outerwear"}
+            for cat in core_categories:
+                if category_counts.get(cat, 0) > 1:
+                    penalty += -1000.0
+            
+            # 2. Context-specific critical violations
             if occasion == "formal" and category_counts.get("outerwear", 0) == 0:
-                penalty += -500.0  # Strong penalty but not -∞ for formal without jacket
+                penalty += -500.0  # Formal without jacket is inappropriate
+            elif occasion == "business" and len(subset) < 3:
+                penalty += -200.0  # Business outfits should be complete
+            elif occasion == "sport" and not any("athletic" in cat_str(i) for i in subset):
+                penalty += -300.0  # Sport outfits need athletic items
             
-            # Duplicate non-accessory categories: -∞ penalty
-            for cat, count in category_counts.items():
-                if cat != "accessory" and count > 1:
-                    penalty += -1000.0
+            # 3. Weather-appropriate violations
+            weather = template["context"]["weather"]
+            if weather == "hot" and len(subset) > 5:
+                penalty += -100.0  # Too many layers for hot weather
+            elif weather == "cold" and category_counts.get("outerwear", 0) == 0:
+                penalty += -150.0  # Missing outerwear for cold weather
+            elif weather == "rain" and not any("boot" in cat_str(i) for i in subset):
+                penalty += -50.0  # Missing weather-appropriate footwear
             
-            # Too many accessories: moderate penalty
+            # 4. Accessory violations
             max_accs = template["accessory_limit"]
-            if category_counts.get("accessory", 0) > max_accs:
-                penalty += -2.0
+            accessory_count = category_counts.get("accessory", 0)
+            if accessory_count > max_accs:
+                penalty += -50.0 * (accessory_count - max_accs)  # Proportional penalty
             
-            # Unbalanced outfit: small penalty
-            if len(subset) < 3:
-                penalty += -1.0
+            # 5. Outfit balance violations
+            if len(subset) < 2:
+                penalty += -200.0  # Too minimal
             elif len(subset) > 6:
-                penalty += -0.5
+                penalty += -100.0  # Too complex
+            elif len(subset) == 2 and occasion in ["formal", "business"]:
+                penalty += -100.0  # Too minimal for formal/business
             
-            # Style consistency bonus
+            # 6. Advanced bonus system
+            # Style consistency bonus (weighted by importance)
             style_score = calculate_style_consistency_score(subset)
-            bonus += style_score * 0.5  # Up to 0.5 bonus for style consistency
+            bonus += style_score * 0.6  # Increased weight for style
             
-            # Color consistency bonus
+            # Color harmony bonus
             color_score = calculate_color_consistency_score(subset)
-            bonus += color_score * 0.3  # Up to 0.3 bonus for color consistency
+            bonus += color_score * 0.4  # Increased weight for color
             
-            # Template adherence bonus
-            if style_score > 0.6:  # Good style match
-                bonus += 0.2
+            # 7. Context-specific bonuses
+            # Formal outfit bonuses
+            if occasion == "formal":
+                if "outerwear" in categories:
+                    bonus += 0.6  # Strong bonus for proper formal layering
+                if len([c for c in categories if c in ["upper", "bottom", "shoe", "outerwear"]]) >= 4:
+                    bonus += 0.4  # Complete formal set bonus
+                if style_score > 0.7:
+                    bonus += 0.3  # High style coherence bonus
             
-            # 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
+            # Business outfit bonuses
+            elif occasion == "business":
+                if len(categories) >= 3:
+                    bonus += 0.3  # Professional completeness
+                if "outerwear" in categories:
+                    bonus += 0.2  # Elevated business look
+                if style_score > 0.6:
+                    bonus += 0.2  # Professional style bonus
             
-            # Formal outfit bonus for including outerwear
-            if occasion == "formal" and "outerwear" in categories:
-                bonus += 0.5  # Strong bonus for formal outfits with jackets
+            # Sport outfit bonuses
+            elif occasion == "sport":
+                if any("athletic" in cat_str(i) for i in subset):
+                    bonus += 0.4  # Athletic functionality
+                if len(subset) <= 3:
+                    bonus += 0.2  # Appropriate minimalism for sport
             
-            # Traditional Pakistani outfit bonus
+            # 8. Traditional Pakistani outfit bonuses
             if outfit_style == "traditional":
                 traditional_items = [cat for cat in categories if any(traditional in cat.lower() for traditional in ["kameez", "kurta", "shalwar", "peshawari", "chappal"])]
-                if len(traditional_items) >= 2:  # At least 2 traditional items
-                    bonus += 0.6  # Strong bonus for traditional outfit combinations
-                if len(traditional_items) == 3:  # Complete traditional set
-                    bonus += 0.3  # Additional bonus for complete traditional outfit
+                if len(traditional_items) >= 2:
+                    bonus += 0.7  # Strong cultural appropriateness bonus
+                if len(traditional_items) == 3:
+                    bonus += 0.4  # Complete traditional set bonus
+                if style_score > 0.6:
+                    bonus += 0.3  # Traditional style coherence
+            
+            # 9. Fashion rule compliance bonuses
+            # Perfect category distribution
+            if all(category_counts.get(cat, 0) <= 1 for cat in core_categories):
+                bonus += 0.3  # Perfect fashion rule compliance
+            
+            # Tasteful accessorizing
+            if 1 <= accessory_count <= 2:
+                bonus += 0.2  # Tasteful accessorizing bonus
+            
+            # 10. Weather-appropriate bonuses
+            if weather == "hot" and len(subset) <= 4:
+                bonus += 0.1  # Appropriate for hot weather
+            elif weather == "cold" and "outerwear" in categories:
+                bonus += 0.2  # Proper cold weather preparation
+            elif weather == "rain" and any("boot" in cat_str(i) for i in subset):
+                bonus += 0.15  # Weather-appropriate footwear
+            
+            # 11. Overall outfit quality bonus
+            if style_score > 0.8 and color_score > 0.7:
+                bonus += 0.3  # Exceptional outfit quality
+            elif style_score > 0.6 and color_score > 0.5:
+                bonus += 0.2  # Good outfit quality
             
             return base_score + penalty + bonus
         
@@ -1031,7 +1285,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:
@@ -1098,8 +1352,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