Update app.py

app.py

@@ -105,8 +105,31 @@ class MultiAttributeClassifier:
                     encoder_path = f"models/classification/{category}_encoder.pkl"
                     if os.path.exists(encoder_path):
                         with open(encoder_path, 'rb') as f:
-                            self.encoders[category] = pickle.load(f)
-                        print(f"✅ Loaded {category} encoder")
+                            encoder_data = pickle.load(f)
+                        
+                        # Handle different encoder formats
+                        if hasattr(encoder_data, 'classes_'):
+                            # Standard LabelEncoder
+                            self.encoders[category] = encoder_data
+                            print(f"✅ Loaded {category} encoder (LabelEncoder) - {len(encoder_data.classes_)} classes")
+                        elif isinstance(encoder_data, dict):
+                            # Dict format - create a wrapper
+                            class EncoderWrapper:
+                                def __init__(self, class_dict):
+                                    if 'classes_' in class_dict:
+                                        self.classes_ = class_dict['classes_']
+                                    elif 'classes' in class_dict:
+                                        self.classes_ = class_dict['classes']
+                                    else:
+                                        # Try to extract classes from dict keys/values
+                                        self.classes_ = list(class_dict.keys()) if class_dict else ['unknown']
+                            
+                            self.encoders[category] = EncoderWrapper(encoder_data)
+                            print(f"✅ Loaded {category} encoder (Dict format) - {len(self.encoders[category].classes_)} classes")
+                            print(f"   Classes: {self.encoders[category].classes_}")
+                        else:
+                            print(f"⚠️ Unknown encoder format for {category}: {type(encoder_data)}")
+                            print(f"   Content preview: {str(encoder_data)[:200]}...")
                     else:
                         print(f"⚠️ {category} encoder not found at {encoder_path}")
                 else:
@@ -287,8 +310,19 @@ class MultiAttributeClassifier:
                     predicted_class_idx = np.argmax(pred, axis=1)[0]
                     confidence = float(np.max(pred))
                     
-                    # Get class name from encoder
-                    class_name = self.encoders[category].classes_[predicted_class_idx]
+                    # Get class name from encoder - handle different formats
+                    try:
+                        if hasattr(self.encoders[category], 'classes_'):
+                            classes = self.encoders[category].classes_
+                            if predicted_class_idx < len(classes):
+                                class_name = classes[predicted_class_idx]
+                            else:
+                                class_name = f"class_{predicted_class_idx}"
+                        else:
+                            class_name = f"class_{predicted_class_idx}"
+                    except Exception as e:
+                        print(f"Error getting class name for {category}: {e}")
+                        class_name = f"class_{predicted_class_idx}"
                     
                     predictions[category] = {
                         'class': class_name,
@@ -431,7 +465,8 @@ print("="*50)
 def analyze_image(image):
     """Analyze uploaded image and provide style recommendations"""
     if image is None:
-        return "Please upload an image first.", "", []
+        choices_with_labels = [(transformation_labels[t], t) for t in available_transformations]
+        return "Please upload an image first.", gr.update(choices=choices_with_labels, value=None, visible=True), []
     
     try:
         # Get predictions for all attributes
@@ -446,23 +481,27 @@ def analyze_image(image):
         # Get style recommendations
         recommendations = classifier.get_style_recommendations(predictions)
         
-        # Format recommendations for display
-        rec_choices = []
+        # Format recommendations for display  
         if recommendations:
-            analysis_text += "## 🎨 Available Style Transfers\n\n"
+            analysis_text += "## 🎨 AI Suggestions\n\n"
             for rec in recommendations:
                 analysis_text += f"**{rec['transformation'].replace('_', ' → ').title()}** ({rec['confidence']*100:.0f}%) {rec['description']}\n\n"
-                rec_choices.append(rec['transformation'])
         else:
-            analysis_text += "No specific style transfer recommendations based on this image.\n"
+            analysis_text += "## 🎨 AI Suggestions\n\nNo specific recommendations - but feel free to try any transformation!\n\n"
         
-        return analysis_text, gr.update(choices=rec_choices, value=None, visible=True), []
+        analysis_text += "---\n**Choose any transformation(s) below - you're not limited to the suggestions!**"
+        
+        # Always return ALL available transformations, regardless of analysis
+        choices_with_labels = [(transformation_labels[t], t) for t in available_transformations]
+        return analysis_text, gr.update(choices=choices_with_labels, value=None, visible=True), []
         
     except Exception as e:
         print(f"Error in analysis: {e}")
         import traceback
         traceback.print_exc()
-        return f"Error analyzing image: {str(e)}", gr.update(visible=False), []
+        # Even if analysis fails, still show all transformations
+        choices_with_labels = [(transformation_labels[t], t) for t in available_transformations]
+        return f"Error analyzing image: {str(e)}\n\n**All transformations still available below:**", gr.update(choices=choices_with_labels, value=None, visible=True), []
 
 def apply_transformations(image, selected_transformations):
     """Apply selected style transformations"""
@@ -489,7 +528,7 @@ def apply_transformations(image, selected_transformations):
     status_text = "\n".join(status_messages)
     return status_text, results
 
-# Available transformations for manual selection
+# Available transformations for manual selection - show user-friendly names
 available_transformations = [
     "day_to_night", "night_to_day", 
     "clear_to_foggy", "foggy_to_clear",
@@ -497,10 +536,23 @@ available_transformations = [
     "summer_to_winter", "winter_to_summer"
 ]
 
+# User-friendly transformation names
+transformation_labels = {
+    "day_to_night": "🌅→🌙 Day to Night",
+    "night_to_day": "🌙→🌅 Night to Day", 
+    "clear_to_foggy": "☀️→🌫️ Clear to Foggy",
+    "foggy_to_clear": "🌫️→☀️ Foggy to Clear",
+    "photo_to_japanese": "📷→🎨 Photo to Japanese Art",
+    "japanese_to_photo": "🎨→📷 Japanese Art to Photo",
+    "summer_to_winter": "🌿→❄️ Summer to Winter",
+    "winter_to_summer": "❄️→🌿 Winter to Summer"
+}
+
 # Create Gradio interface
 with gr.Blocks(title="Intelligent Multi-Attribute Style Transfer", theme=gr.themes.Soft()) as demo:
     gr.Markdown("# 🎨 Intelligent Multi-Attribute Style Transfer")
-    gr.Markdown("Upload an image and our AI will analyze multiple attributes (content, style, time, weather) and suggest relevant style transfers using trained GAN models!")
+    gr.Markdown("Upload an image and our AI will analyze it to provide smart suggestions - **but you can choose ANY transformation you want!**")
+    gr.Markdown("💡 **Tip:** You can skip analysis and apply transformations directly!")
     
     # Show available transformations
     gr.Markdown("## Available Transformations:")
@@ -508,18 +560,20 @@ with gr.Blocks(title="Intelligent Multi-Attribute Style Transfer", theme=gr.them
     gr.Markdown("• 🎨 Photo ↔ Japanese ukiyo-e art style (CycleGAN)")
     gr.Markdown("• 🌫️ Foggy ↔ Clear weather transformation (CycleGAN)")
     gr.Markdown("• 🌿 Summer ↔ Winter seasonal atmosphere (CycleGAN)")
+    gr.Markdown("---")
     
     with gr.Row():
         with gr.Column(scale=1):
             image_input = gr.Image(label="📤 Upload Your Image", type="pil")
-            analyze_btn = gr.Button("🔍 Analyze Image", variant="primary")
+            analyze_btn = gr.Button("🔍 Analyze Image (Optional)", variant="primary")
             
         with gr.Column(scale=1):
             analysis_output = gr.Markdown("## 📊 Image Analysis Results", label="Analysis Results")
             recommendations = gr.CheckboxGroup(
-                choices=[], 
-                label="🎨 Available Style Transfers",
-                visible=False
+                choices=[(transformation_labels[t], t) for t in available_transformations], 
+                label="🎨 Choose Transformations (All Available)",
+                visible=True,
+                value=None
             )
     
     with gr.Row():