Add tabbed interface with visible Training Guide and About sections

app.py

@@ -116,28 +116,288 @@ def enhance_image_simple(
         logger.error(f"Enhancement failed: {e}", exc_info=True)
         raise gr.Error(f"Enhancement failed: {str(e)}")
 
-# Create simple interface
-iface = gr.Interface(
-    fn=enhance_image_simple,
-    inputs=[
-        gr.Image(label="Input Image", type="pil"),
-        gr.Slider(0.1, 0.8, value=0.3, step=0.05, label="Strength", info="Lower = more faithful to input, Higher = more creative"),
-        gr.Slider(1.0, 15.0, value=5.5, step=0.5, label="Guidance Scale", info="How closely to follow the prompt"),
-        gr.Textbox(
-            label="Additional Prompt (Optional)", 
-            placeholder="e.g., modern minimalist, glass facade, sunset lighting...",
-            lines=2,
-            info="Add custom details to enhance specific aspects"
-        ),
-        gr.Checkbox(label="Enable Upscaling (2x)", value=True),
-        gr.Checkbox(label="Enable Post-Processing", value=True)
-    ],
-    outputs=gr.Image(label="Enhanced Image", type="pil"),
-    title="🏛️ Architecture AI Enhancer",
-    description="Transform architectural renders with AI-powered enhancement using Stable Diffusion 1.5",
-    article="""
-    ### Tips for Best Results:
-    - Use high-quality architectural renders
+# Create interface with tabs
+with gr.Blocks(title="🏛️ Architecture AI Enhancer") as demo:
+    gr.Markdown("""
+    # 🏛️ Architecture AI Enhancer
+    Transform your architectural renders with AI-powered enhancement using Stable Diffusion 1.5
+    """)
+    
+    with gr.Tabs():
+        # Tab 1: Enhancement
+        with gr.Tab("✨ Enhance Image"):
+            with gr.Row():
+                with gr.Column():
+                    input_image = gr.Image(label="📤 Input Image", type="pil")
+                    
+                    with gr.Accordion("⚙️ Advanced Settings", open=False):
+                        strength = gr.Slider(
+                            0.1, 0.8, value=0.3, step=0.05,
+                            label="Denoising Strength",
+                            info="Lower = more faithful to input, Higher = more creative"
+                        )
+                        guidance_scale = gr.Slider(
+                            1.0, 15.0, value=5.5, step=0.5,
+                            label="Guidance Scale",
+                            info="How closely to follow the prompt"
+                        )
+                        custom_prompt = gr.Textbox(
+                            label="Additional Prompt (Optional)",
+                            placeholder="e.g., modern minimalist, glass facade, sunset lighting...",
+                            lines=2,
+                            info="Add custom details to enhance specific aspects"
+                        )
+                        use_upscaler = gr.Checkbox(label="Enable Upscaling (2x)", value=True)
+                        use_postprocess = gr.Checkbox(label="Enable Post-Processing", value=True)
+                    
+                    enhance_btn = gr.Button("✨ Enhance Image", variant="primary", size="lg")
+                
+                with gr.Column():
+                    output_image = gr.Image(label="✅ Enhanced Result", type="pil")
+                    
+                    gr.Markdown("""
+                    ### 📝 Tips for Best Results:
+                    - Use high-quality architectural renders as input
+                    - Start with default settings and adjust if needed
+                    - Lower strength for subtle enhancements
+                    - Higher strength for more dramatic changes
+                    - Processing takes 2-5 minutes on CPU, ~30 seconds on GPU
+                    """)
+            
+            # Connect the button
+            enhance_btn.click(
+                fn=enhance_image_simple,
+                inputs=[input_image, strength, guidance_scale, custom_prompt, use_upscaler, use_postprocess],
+                outputs=output_image
+            )
+        
+        # Tab 2: Training Guide
+        with gr.Tab("🎓 Custom Training"):
+            gr.Markdown("""
+            # 🎓 Train Your Own Custom LoRA Model
+            
+            Want to teach the AI your specific architectural style? You can train a custom LoRA model!
+            
+            ## ⚠️ Important Note
+            
+            **Training is not available on this HF Space** due to computational requirements. However, you can train locally and deploy your custom model!
+            
+            ## 🚀 What is LoRA Training?
+            
+            LoRA (Low-Rank Adaptation) allows you to fine-tune the AI with just 10-50 image pairs to learn:
+            - Your specific architectural rendering style
+            - Preferred lighting and atmosphere
+            - Consistent material treatments
+            - Unique design aesthetics
+            
+            ### Benefits:
+            - ✅ **Fast Training**: Only 1000 steps needed (~20-30 min on GPU)
+            - ✅ **Small Models**: LoRA weights are only ~10-50 MB
+            - ��� **Style Consistency**: Perfect for architectural firms with specific styles
+            - ✅ **Efficient**: Works on consumer GPUs
+            
+            ---
+            
+            ## 📋 Training Process Overview
+            
+            ### Step 1: Prepare Training Data
+            
+            Create **image pairs**:
+            - **Input**: Your base architectural render (before)
+            - **Target**: Your ideal enhanced result (after)
+            
+            **Requirements:**
+            - Minimum: 10 pairs (recommended: 20-50)
+            - Format: PNG or JPG
+            - Resolution: 512x512 to 1024x1024
+            
+            **Example structure:**
+            ```
+            training_data/
+              inputs/
+                building_001_input.png
+                building_002_input.png
+              targets/
+                building_001_target.png
+                building_002_target.png
+            ```
+            
+            ### Step 2: Setup Local Backend
+            
+            ```bash
+            cd architecture-ai-enhancer/backend
+            pip install -r requirements.txt
+            uvicorn main:app --host 0.0.0.0 --port 8000
+            ```
+            
+            ### Step 3: Upload Training Pairs
+            
+            Use the API at `http://localhost:8000/docs` to upload your image pairs:
+            
+            ```python
+            import requests
+            
+            files = {
+                'input_image': open('building_001_input.png', 'rb'),
+                'target_image': open('building_001_target.png', 'rb')
+            }
+            response = requests.post(
+                'http://localhost:8000/training/upload_pair',
+                files=files
+            )
+            ```
+            
+            ### Step 4: Start Training
+            
+            ```python
+            config = {
+                "train_steps": 1000,
+                "learning_rate": 1e-4,
+                "lora_rank": 8,
+                "batch_size": 1
+            }
+            
+            response = requests.post(
+                'http://localhost:8000/training/start',
+                json=config
+            )
+            ```
+            
+            ### Step 5: Use Your Custom Model
+            
+            Once trained, your custom LoRA is automatically used for all enhancements!
+            
+            ---
+            
+            ## 🎨 Training Tips
+            
+            **For Subtle Enhancements:**
+            - train_steps: 500
+            - learning_rate: 5e-5
+            - lora_rank: 4
+            
+            **For Dramatic Style Changes:**
+            - train_steps: 1500
+            - learning_rate: 1e-4
+            - lora_rank: 12
+            
+            **Balanced (Recommended):**
+            - train_steps: 1000
+            - learning_rate: 1e-4
+            - lora_rank: 8
+            
+            ---
+            
+            ## 📚 Complete Documentation
+            
+            For detailed step-by-step instructions, troubleshooting, and advanced techniques, see:
+            
+            **[📖 Complete LoRA Training Guide](https://huggingface.co/spaces/TransformacionDigitalAA/ArchEnhancer/blob/main/TRAINING_GUIDE.md)**
+            
+            This includes:
+            - Detailed API usage examples
+            - Complete Python training script
+            - Troubleshooting common issues
+            - Best practices for creating training data
+            - How to deploy your custom LoRA
+            
+            ---
+            
+            ## 💡 Use Cases
+            
+            - **Architecture Firms**: Train on your signature rendering style
+            - **Game Studios**: Consistent environmental concept art
+            - **VFX Artists**: Specific lighting and atmosphere
+            - **Real Estate**: Standardized visualization style
+            
+            ---
+            
+            ## 🔗 Resources
+            
+            - [Backend GitHub Repository](https://github.com/yourusername/architecture-ai-enhancer)
+            - [LoRA Paper](https://arxiv.org/abs/2106.09685)
+            - [Diffusers Documentation](https://huggingface.co/docs/diffusers/)
+            """)
+        
+        # Tab 3: About
+        with gr.Tab("ℹ️ About"):
+            gr.Markdown("""
+            # About Architecture AI Enhancer
+            
+            ## 🔧 Technical Details
+            
+            - **Model**: Stable Diffusion 1.5 (runwayml/stable-diffusion-v1-5)
+            - **Upscaler**: ESRGAN with fallback to Lanczos
+            - **Framework**: PyTorch + Diffusers
+            - **Interface**: Gradio 4.20.0
+            - **Version**: 1.0.0
+            
+            ## ⚙️ Settings Guide
+            
+            ### Denoising Strength (0.1-0.8)
+            Controls how much the AI modifies your input image:
+            - **0.2-0.3**: Subtle enhancements (recommended for most cases)
+            - **0.4-0.5**: Moderate changes
+            - **0.6-0.8**: Dramatic transformations
+            
+            ### Guidance Scale (1-15)
+            How closely the AI follows the prompt:
+            - **4-6**: Natural, balanced results (recommended)
+            - **7-10**: More stylized output
+            - **11-15**: Very strong prompt adherence
+            
+            ### Custom Prompt
+            Add specific details to guide the enhancement:
+            - Lighting: "sunset lighting", "dramatic shadows"
+            - Style: "modern minimalist", "brutalist concrete"
+            - Materials: "glass facade", "wooden accents"
+            - Atmosphere: "foggy morning", "golden hour"
+            
+            ## 🚀 Features
+            
+            - ✅ AI-powered enhancement with Stable Diffusion
+            - ✅ 2x image upscaling
+            - ✅ Professional post-processing
+            - ✅ Custom prompt support
+            - ✅ Adjustable parameters
+            - ✅ Custom LoRA training (local)
+            
+            ## 📊 Performance
+            
+            - **CPU (HF Spaces Free Tier)**: 2-5 minutes per image
+            - **GPU (Local/Paid)**: ~30 seconds per image
+            
+            ## 🙏 Credits
+            
+            Built with:
+            - [Stable Diffusion](https://github.com/CompVis/stable-diffusion)
+            - [Diffusers](https://github.com/huggingface/diffusers)
+            - [Gradio](https://gradio.app)
+            - [PyTorch](https://pytorch.org)
+            
+            ## 📝 License
+            
+            MIT License - Free for commercial and personal use
+            
+            ---
+            
+            **Made with ❤️ for the architecture community**
+            """)
+
+if __name__ == "__main__":
+    # Check if running on HF Spaces
+    is_spaces = os.getenv("SPACE_ID") is not None
+    
+    if is_spaces:
+        # HF Spaces specific configuration
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False
+        )
+    else:
+        # Local development
+        demo.launch(share=True)
     - Lower strength = more faithful to input
     - Higher strength = more creative output
     - Processing takes 2-5 minutes on CPU