Implement remote image processing via local server, enhancing the editing function with server connection checks and performance settings. Update UI to include local server setup instructions and modify the main editing function to handle server requests.

HYBRID_SETUP.md

@@ -0,0 +1,119 @@
+# Hybrid Deployment Setup Instructions
+
+This document provides detailed instructions for setting up the hybrid deployment of the AI-Powered Facial and Body Feature Editor, which uses your local GPU for processing while keeping the interface hosted on Hugging Face Spaces.
+
+## Overview
+
+The hybrid deployment consists of two components:
+1. **Hugging Face Space** - Hosts the user interface and handles file uploads
+2. **Local GPU Server** - Runs on your computer and processes the images using your NVIDIA 3060 GPU
+
+This approach gives you the best of both worlds: the convenience of a hosted web application with the performance of your local GPU.
+
+## Requirements
+
+### For the Local Server
+- Python 3.8 or higher
+- PyTorch with CUDA support
+- NVIDIA GPU with at least 6GB VRAM (your NVIDIA 3060 with 6GB is perfect)
+- The following Python packages:
+  - gradio
+  - torch
+  - torchvision
+  - diffusers
+  - transformers
+  - opencv-python
+  - pillow
+  - numpy
+
+## Step 1: Set Up the Local Server
+
+1. Download the entire project zip file and extract it to a folder on your computer.
+
+2. Install the required dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. Make sure you have PyTorch with CUDA support:
+   ```bash
+   pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118
+   ```
+
+4. Run the local server:
+   ```bash
+   python local_server.py
+   ```
+
+5. The server will start and display a URL like `https://12345.gradio.app` (your number will be different). This is your local server's public URL.
+
+6. Keep this terminal window open while using the application.
+
+## Step 2: Update the Hugging Face Space
+
+1. In your Hugging Face Space repository, replace the current `app.py` file with the `app_hybrid.py` file.
+
+2. Rename `app_hybrid.py` to `app.py` or update the file directly.
+
+3. Commit and push the changes:
+   ```bash
+   git add app.py
+   git commit -m "Update to hybrid deployment mode"
+   git push
+   ```
+
+4. Hugging Face will automatically rebuild your Space with the updated code.
+
+## Step 3: Connect the Components
+
+1. Once your Hugging Face Space is rebuilt, open it in your browser.
+
+2. In the "Local GPU Server Connection" section, paste the URL from your local server (the `https://12345.gradio.app` URL).
+
+3. Click "Check Connection" to verify that the connection is working.
+
+4. If the connection is successful, you'll see "Connected successfully" in the status field.
+
+5. Now you can upload images and use the application as normal, but all processing will be done on your local GPU.
+
+## Performance Tuning
+
+You can adjust the following settings to balance quality and performance:
+
+1. **Inference Steps**: Lower values (10-15) are faster, higher values (30-50) give better quality.
+
+2. **Guidance Scale**: Controls how closely the model follows your prompt. Values between 5-10 work well.
+
+3. **Processing Resolution**: Lower resolutions are faster but may lose detail. 512x512 is a good balance.
+
+## Troubleshooting
+
+### Connection Issues
+- Make sure your local server is running
+- Check that you've entered the correct URL
+- Ensure your firewall isn't blocking the connection
+- Try restarting the local server
+
+### GPU Memory Issues
+- Reduce the inference steps
+- Use a lower processing resolution
+- Close other GPU-intensive applications
+
+### Image Processing Errors
+- Try using a different image
+- Reduce the complexity of your edits
+- Check the local server terminal for error messages
+
+## Security Considerations
+
+The local server creates a temporary public URL that anyone can access while it's running. For security:
+
+1. Only run the local server when you're actively using the application
+2. Stop the server when you're done (Ctrl+C in the terminal)
+3. Don't share your local server URL with others unless you want them to use your GPU
+
+## Additional Notes
+
+- The local server will use your GPU resources, which might affect other applications running on your computer
+- Processing time will vary based on your GPU capabilities, but should be significantly faster than the CPU-only version
+- You can monitor GPU usage in the local server interface or using tools like NVIDIA Task Manager

app.py

@@ -1,16 +1,10 @@
 import os
 import gradio as gr
-import torch
+import requests
 from PIL import Image
 import numpy as np
-from models.ledits_model import LEDITSModel
-from utils.image_processing import preprocess_image, postprocess_image
-from utils.feature_detection import detect_features, create_mask
-
-# Initialize models
-def initialize_models():
-    ledits_model = LEDITSModel()
-    return ledits_model
+import io
+import json
 
 # Global variables
 FEATURE_TYPES = ["Eyes", "Nose", "Lips", "Face Shape", "Hair", "Body"]
@@ -23,50 +17,74 @@ MODIFICATION_PRESETS = {
     "Body": ["Slim", "Athletic", "Curvy", "Muscular"]
 }
 
-# Main editing function
-def edit_image(image, feature_type, modification_type, intensity, 
-               custom_prompt="", use_custom_prompt=False):
+# Remote processing function
+def process_with_local_server(image, feature_type, modification_type, intensity, 
+                             num_inference_steps, guidance_scale, resolution,
+                             custom_prompt="", use_custom_prompt=False, server_url=None):
     if image is None:
         return None, "Please upload an image first."
     
+    if server_url is None or server_url == "":
+        return image, "Error: Local server URL not provided. Please enter your local server URL."
+    
     try:
-        # Convert to numpy array if needed
-        if isinstance(image, Image.Image):
-            image_np = np.array(image)
+        # Ensure server URL ends with /api/predict/
+        if not server_url.endswith("/"):
+            server_url += "/"
+        if not server_url.endswith("api/predict/"):
+            server_url += "api/predict/"
+        
+        # Convert image to bytes
+        if isinstance(image, np.ndarray):
+            image_pil = Image.fromarray(image)
         else:
-            image_np = image
+            image_pil = image
             
-        # Preprocess image
-        processed_image = preprocess_image(image_np)
+        img_byte_arr = io.BytesIO()
+        image_pil.save(img_byte_arr, format='PNG')
+        img_byte_arr.seek(0)
         
-        # Detect features and create mask
-        features = detect_features(processed_image)
-        mask = create_mask(processed_image, feature_type, features)
+        # Prepare the request data
+        files = {
+            'input_image': ('image.png', img_byte_arr, 'image/png')
+        }
         
-        # Get model
-        ledits_model = initialize_models()
+        data = {
+            'feature_type': feature_type,
+            'modification_type': modification_type,
+            'intensity': str(intensity),
+            'num_inference_steps': str(num_inference_steps),
+            'guidance_scale': str(guidance_scale),
+            'resolution': resolution,
+            'custom_prompt': custom_prompt,
+            'use_custom_prompt': str(use_custom_prompt).lower()
+        }
         
-        # Prepare prompt
-        if use_custom_prompt and custom_prompt:
-            prompt = custom_prompt
-        else:
-            prompt = f"{feature_type} {modification_type}"
-        
-        # Apply edit
-        edited_image = ledits_model.edit_image(
-            processed_image, 
-            mask, 
-            prompt, 
-            intensity=intensity
-        )
-        
-        # Postprocess
-        final_image = postprocess_image(edited_image, processed_image, mask)
+        # Send request to local server
+        response = requests.post(server_url, files=files, data=data)
         
-        return final_image, "Edit completed successfully."
+        if response.status_code == 200:
+            # Parse the response
+            result = response.json()
+            
+            # Get the output image
+            if 'data' in result and len(result['data']) >= 1:
+                output_data = result['data'][0]
+                if isinstance(output_data, str) and output_data.startswith('data:image'):
+                    # Handle base64 encoded image
+                    import base64
+                    image_data = output_data.split(',')[1]
+                    decoded_image = base64.b64decode(image_data)
+                    output_image = Image.open(io.BytesIO(decoded_image))
+                    return output_image, "Edit completed successfully."
+            
+            # If we couldn't parse the image from the response
+            return image, f"Error: Could not parse response from local server."
+        else:
+            return image, f"Error: Local server returned status code {response.status_code}."
     
     except Exception as e:
-        return image, f"Error during editing: {str(e)}"
+        return image, f"Error connecting to local server: {str(e)}"
 
 # UI Components
 def create_ui():
@@ -74,6 +92,37 @@ def create_ui():
         gr.Markdown("# AI-Powered Facial & Body Feature Editor")
         gr.Markdown("Upload an image and use the controls to edit specific facial and body features.")
         
+        # Server connection
+        with gr.Group():
+            gr.Markdown("### Local GPU Server Connection")
+            server_url = gr.Textbox(
+                label="Local Server URL", 
+                placeholder="Enter the URL of your local GPU server (e.g., https://12345.gradio.app)",
+                value=""
+            )
+            server_status = gr.Textbox(label="Server Status", value="Not connected", interactive=False)
+            
+            def check_server(url):
+                if not url:
+                    return "Not connected"
+                
+                try:
+                    # Ensure URL ends with /
+                    if not url.endswith("/"):
+                        url += "/"
+                    
+                    # Try to connect to the server
+                    response = requests.get(url)
+                    if response.status_code == 200:
+                        return "Connected successfully"
+                    else:
+                        return f"Error: Server returned status code {response.status_code}"
+                except Exception as e:
+                    return f"Error connecting to server: {str(e)}"
+            
+            check_button = gr.Button("Check Connection")
+            check_button.click(fn=check_server, inputs=server_url, outputs=server_status)
+        
         with gr.Row():
             with gr.Column(scale=1):
                 # Input controls
@@ -113,6 +162,28 @@ def create_ui():
                         placeholder="e.g., blue eyes with long eyelashes"
                     )
                 
+                with gr.Group():
+                    gr.Markdown("### Performance Settings")
+                    num_inference_steps = gr.Slider(
+                        minimum=5,
+                        maximum=50,
+                        value=20,
+                        step=1,
+                        label="Inference Steps (lower = faster, higher = better quality)"
+                    )
+                    guidance_scale = gr.Slider(
+                        minimum=1.0,
+                        maximum=15.0,
+                        value=7.5,
+                        step=0.5,
+                        label="Guidance Scale (lower = more creative, higher = more accurate)"
+                    )
+                    resolution = gr.Dropdown(
+                        choices=["Original", "512x512", "768x768", "1024x1024"],
+                        label="Processing Resolution",
+                        value="512x512"
+                    )
+                
                 edit_button = gr.Button("Apply Edit", variant="primary")
                 reset_button = gr.Button("Reset")
                 status_text = gr.Textbox(label="Status", interactive=False)
@@ -136,14 +207,18 @@ def create_ui():
         )
         
         edit_button.click(
-            fn=edit_image,
+            fn=process_with_local_server,
             inputs=[
                 input_image, 
                 feature_type, 
                 modification_type, 
-                intensity, 
+                intensity,
+                num_inference_steps,
+                guidance_scale,
+                resolution,
                 custom_prompt, 
-                use_custom_prompt
+                use_custom_prompt,
+                server_url
             ],
             outputs=[output_image, status_text]
         )
@@ -157,8 +232,6 @@ def create_ui():
             outputs=[output_image, status_text]
         )
         
-        # Removed examples section to avoid file path errors
-        
         # Add ethical usage notice
         gr.Markdown("""
         ## Ethical Usage Notice
@@ -172,6 +245,22 @@ def create_ui():
         By using this application, you agree to these terms.
         """)
         
+        # Add local server setup instructions
+        gr.Markdown("""
+        ## Local GPU Server Setup Instructions
+        
+        To use your local GPU for processing:
+        
+        1. Download and run the local_server.py file on your computer
+        2. Make sure you have the required dependencies installed
+        3. The server will start and provide a public URL (copy this URL)
+        4. Paste the URL into the "Local Server URL" field above
+        5. Click "Check Connection" to verify
+        6. Once connected, all processing will use your local GPU
+        
+        This hybrid approach gives you the best performance while keeping the interface accessible from anywhere.
+        """)
+        
     return app
 
 # Launch the app

app_hybrid.py

@@ -0,0 +1,269 @@
+import os
+import gradio as gr
+import requests
+from PIL import Image
+import numpy as np
+import io
+import json
+
+# Global variables
+FEATURE_TYPES = ["Eyes", "Nose", "Lips", "Face Shape", "Hair", "Body"]
+MODIFICATION_PRESETS = {
+    "Eyes": ["Larger", "Smaller", "Change Color", "Change Shape"],
+    "Nose": ["Refine", "Reshape", "Resize"],
+    "Lips": ["Fuller", "Thinner", "Change Color"],
+    "Face Shape": ["Slim", "Round", "Define Jawline", "Soften Features"],
+    "Hair": ["Change Color", "Change Style", "Add Volume"],
+    "Body": ["Slim", "Athletic", "Curvy", "Muscular"]
+}
+
+# Remote processing function
+def process_with_local_server(image, feature_type, modification_type, intensity, 
+                             num_inference_steps, guidance_scale, resolution,
+                             custom_prompt="", use_custom_prompt=False, server_url=None):
+    if image is None:
+        return None, "Please upload an image first."
+    
+    if server_url is None or server_url == "":
+        return image, "Error: Local server URL not provided. Please enter your local server URL."
+    
+    try:
+        # Ensure server URL ends with /api/predict/
+        if not server_url.endswith("/"):
+            server_url += "/"
+        if not server_url.endswith("api/predict/"):
+            server_url += "api/predict/"
+        
+        # Convert image to bytes
+        if isinstance(image, np.ndarray):
+            image_pil = Image.fromarray(image)
+        else:
+            image_pil = image
+            
+        img_byte_arr = io.BytesIO()
+        image_pil.save(img_byte_arr, format='PNG')
+        img_byte_arr.seek(0)
+        
+        # Prepare the request data
+        files = {
+            'input_image': ('image.png', img_byte_arr, 'image/png')
+        }
+        
+        data = {
+            'feature_type': feature_type,
+            'modification_type': modification_type,
+            'intensity': str(intensity),
+            'num_inference_steps': str(num_inference_steps),
+            'guidance_scale': str(guidance_scale),
+            'resolution': resolution,
+            'custom_prompt': custom_prompt,
+            'use_custom_prompt': str(use_custom_prompt).lower()
+        }
+        
+        # Send request to local server
+        response = requests.post(server_url, files=files, data=data)
+        
+        if response.status_code == 200:
+            # Parse the response
+            result = response.json()
+            
+            # Get the output image
+            if 'data' in result and len(result['data']) >= 1:
+                output_data = result['data'][0]
+                if isinstance(output_data, str) and output_data.startswith('data:image'):
+                    # Handle base64 encoded image
+                    import base64
+                    image_data = output_data.split(',')[1]
+                    decoded_image = base64.b64decode(image_data)
+                    output_image = Image.open(io.BytesIO(decoded_image))
+                    return output_image, "Edit completed successfully."
+            
+            # If we couldn't parse the image from the response
+            return image, f"Error: Could not parse response from local server."
+        else:
+            return image, f"Error: Local server returned status code {response.status_code}."
+    
+    except Exception as e:
+        return image, f"Error connecting to local server: {str(e)}"
+
+# UI Components
+def create_ui():
+    with gr.Blocks(title="AI-Powered Facial & Body Feature Editor") as app:
+        gr.Markdown("# AI-Powered Facial & Body Feature Editor")
+        gr.Markdown("Upload an image and use the controls to edit specific facial and body features.")
+        
+        # Server connection
+        with gr.Group():
+            gr.Markdown("### Local GPU Server Connection")
+            server_url = gr.Textbox(
+                label="Local Server URL", 
+                placeholder="Enter the URL of your local GPU server (e.g., https://12345.gradio.app)",
+                value=""
+            )
+            server_status = gr.Textbox(label="Server Status", value="Not connected", interactive=False)
+            
+            def check_server(url):
+                if not url:
+                    return "Not connected"
+                
+                try:
+                    # Ensure URL ends with /
+                    if not url.endswith("/"):
+                        url += "/"
+                    
+                    # Try to connect to the server
+                    response = requests.get(url)
+                    if response.status_code == 200:
+                        return "Connected successfully"
+                    else:
+                        return f"Error: Server returned status code {response.status_code}"
+                except Exception as e:
+                    return f"Error connecting to server: {str(e)}"
+            
+            check_button = gr.Button("Check Connection")
+            check_button.click(fn=check_server, inputs=server_url, outputs=server_status)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                # Input controls
+                input_image = gr.Image(label="Upload Image", type="pil")
+                
+                with gr.Group():
+                    gr.Markdown("### Feature Selection")
+                    feature_type = gr.Dropdown(
+                        choices=FEATURE_TYPES, 
+                        label="Select Feature", 
+                        value="Eyes"
+                    )
+                    
+                    # Initialize with choices for the default feature (Eyes)
+                    modification_type = gr.Dropdown(
+                        choices=MODIFICATION_PRESETS["Eyes"], 
+                        label="Modification Type", 
+                        value="Larger"
+                    )
+                    
+                    intensity = gr.Slider(
+                        minimum=0.1, 
+                        maximum=1.0, 
+                        value=0.5, 
+                        step=0.1, 
+                        label="Intensity"
+                    )
+                
+                with gr.Group():
+                    gr.Markdown("### Custom Prompt (Advanced)")
+                    use_custom_prompt = gr.Checkbox(
+                        label="Use Custom Prompt", 
+                        value=False
+                    )
+                    custom_prompt = gr.Textbox(
+                        label="Custom Prompt", 
+                        placeholder="e.g., blue eyes with long eyelashes"
+                    )
+                
+                with gr.Group():
+                    gr.Markdown("### Performance Settings")
+                    num_inference_steps = gr.Slider(
+                        minimum=5,
+                        maximum=50,
+                        value=20,
+                        step=1,
+                        label="Inference Steps (lower = faster, higher = better quality)"
+                    )
+                    guidance_scale = gr.Slider(
+                        minimum=1.0,
+                        maximum=15.0,
+                        value=7.5,
+                        step=0.5,
+                        label="Guidance Scale (lower = more creative, higher = more accurate)"
+                    )
+                    resolution = gr.Dropdown(
+                        choices=["Original", "512x512", "768x768", "1024x1024"],
+                        label="Processing Resolution",
+                        value="512x512"
+                    )
+                
+                edit_button = gr.Button("Apply Edit", variant="primary")
+                reset_button = gr.Button("Reset")
+                status_text = gr.Textbox(label="Status", interactive=False)
+            
+            with gr.Column(scale=1):
+                # Output display
+                output_image = gr.Image(label="Edited Image", type="pil")
+                
+                with gr.Accordion("Edit History", open=False):
+                    edit_history = gr.State([])
+                    history_gallery = gr.Gallery(label="Previous Edits")
+        
+        # Event handlers
+        def update_modification_choices(feature):
+            return gr.Dropdown(choices=MODIFICATION_PRESETS[feature])
+        
+        feature_type.change(
+            fn=update_modification_choices,
+            inputs=feature_type,
+            outputs=modification_type
+        )
+        
+        edit_button.click(
+            fn=process_with_local_server,
+            inputs=[
+                input_image, 
+                feature_type, 
+                modification_type, 
+                intensity,
+                num_inference_steps,
+                guidance_scale,
+                resolution,
+                custom_prompt, 
+                use_custom_prompt,
+                server_url
+            ],
+            outputs=[output_image, status_text]
+        )
+        
+        def reset_image():
+            return None, "Image reset."
+        
+        reset_button.click(
+            fn=reset_image,
+            inputs=[],
+            outputs=[output_image, status_text]
+        )
+        
+        # Add ethical usage notice
+        gr.Markdown("""
+        ## Ethical Usage Notice
+        
+        This tool is designed for creative and personal use. Please ensure:
+        
+        - You have appropriate rights to edit the images you upload
+        - You use this tool responsibly and respect the dignity of individuals
+        - You understand that AI-generated modifications are artificial and may not represent reality
+        
+        By using this application, you agree to these terms.
+        """)
+        
+        # Add local server setup instructions
+        gr.Markdown("""
+        ## Local GPU Server Setup Instructions
+        
+        To use your local GPU for processing:
+        
+        1. Download and run the local_server.py file on your computer
+        2. Make sure you have the required dependencies installed
+        3. The server will start and provide a public URL (copy this URL)
+        4. Paste the URL into the "Local Server URL" field above
+        5. Click "Check Connection" to verify
+        6. Once connected, all processing will use your local GPU
+        
+        This hybrid approach gives you the best performance while keeping the interface accessible from anywhere.
+        """)
+        
+    return app
+
+# Launch the app
+if __name__ == "__main__":
+    app = create_ui()
+    app.launch(server_name="0.0.0.0", share=False)

local_server.py

@@ -0,0 +1,197 @@
+import os
+import gradio as gr
+import torch
+from PIL import Image
+import numpy as np
+from models.ledits_model import LEDITSModel
+from utils.image_processing import preprocess_image, postprocess_image
+from utils.feature_detection import detect_features, create_mask
+
+# Initialize models with GPU support
+def initialize_models(device=None):
+    if device is None:
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+    
+    print(f"Using device: {device}")
+    if device == "cuda":
+        print(f"GPU: {torch.cuda.get_device_name(0)}")
+        print(f"Memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")
+    
+    ledits_model = LEDITSModel(device=device)
+    return ledits_model
+
+# Main editing function
+def edit_image(image, feature_type, modification_type, intensity, 
+               num_inference_steps, guidance_scale, resolution,
+               custom_prompt="", use_custom_prompt=False):
+    if image is None:
+        return None, "Please upload an image first."
+    
+    try:
+        # Convert to numpy array if needed
+        if isinstance(image, Image.Image):
+            image_np = np.array(image)
+        else:
+            image_np = image
+        
+        # Resize image based on resolution setting
+        if resolution != "Original":
+            max_dim = int(resolution.split("x")[0])
+            height, width = image_np.shape[:2]
+            
+            if height > width:
+                new_height = min(max_dim, height)
+                new_width = int(width * (new_height / height))
+            else:
+                new_width = min(max_dim, width)
+                new_height = int(height * (new_width / width))
+            
+            image_np = Image.fromarray(image_np).resize((new_width, new_height), Image.LANCZOS)
+            image_np = np.array(image_np)
+            
+        # Preprocess image
+        processed_image = preprocess_image(image_np)
+        
+        # Detect features and create mask
+        features = detect_features(processed_image)
+        mask = create_mask(processed_image, feature_type, features)
+        
+        # Get model
+        ledits_model = initialize_models()
+        
+        # Prepare prompt
+        if use_custom_prompt and custom_prompt:
+            prompt = custom_prompt
+        else:
+            prompt = f"{feature_type} {modification_type}"
+        
+        # Apply edit with custom parameters
+        edited_image = ledits_model.edit_image(
+            processed_image, 
+            mask, 
+            prompt, 
+            intensity=intensity,
+            guidance_scale=guidance_scale,
+            num_inference_steps=num_inference_steps
+        )
+        
+        # Postprocess
+        final_image = postprocess_image(edited_image, processed_image, mask)
+        
+        return final_image, "Edit completed successfully."
+    
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return image, f"Error during editing: {str(e)}"
+
+# Create the server interface
+def create_server():
+    with gr.Blocks(title="AI-Powered Facial & Body Feature Editor - Local Server") as server:
+        gr.Markdown("# AI-Powered Facial & Body Feature Editor - Local GPU Server")
+        gr.Markdown("This is the local GPU server component. Keep this running to process edits from the Hugging Face Space.")
+        
+        # Input components
+        with gr.Row():
+            with gr.Column():
+                input_image = gr.Image(label="Input Image", type="pil")
+                feature_type = gr.Dropdown(
+                    choices=["Eyes", "Nose", "Lips", "Face Shape", "Hair", "Body"],
+                    label="Feature Type",
+                    value="Eyes"
+                )
+                modification_type = gr.Dropdown(
+                    choices=["Larger", "Smaller", "Change Color", "Change Shape"],
+                    label="Modification Type",
+                    value="Larger"
+                )
+                intensity = gr.Slider(
+                    minimum=0.1,
+                    maximum=1.0,
+                    value=0.5,
+                    step=0.1,
+                    label="Intensity"
+                )
+                custom_prompt = gr.Textbox(
+                    label="Custom Prompt",
+                    placeholder="e.g., blue eyes with long eyelashes"
+                )
+                use_custom_prompt = gr.Checkbox(
+                    label="Use Custom Prompt",
+                    value=False
+                )
+                
+                # Performance settings
+                with gr.Group():
+                    gr.Markdown("### Performance Settings")
+                    num_inference_steps = gr.Slider(
+                        minimum=5,
+                        maximum=50,
+                        value=20,
+                        step=1,
+                        label="Inference Steps (lower = faster, higher = better quality)"
+                    )
+                    guidance_scale = gr.Slider(
+                        minimum=1.0,
+                        maximum=15.0,
+                        value=7.5,
+                        step=0.5,
+                        label="Guidance Scale (lower = more creative, higher = more accurate)"
+                    )
+                    resolution = gr.Dropdown(
+                        choices=["Original", "512x512", "768x768", "1024x1024"],
+                        label="Processing Resolution",
+                        value="512x512"
+                    )
+            
+            with gr.Column():
+                output_image = gr.Image(label="Output Image", type="pil")
+                status_text = gr.Textbox(label="Status", interactive=False)
+                
+                # GPU info display
+                gpu_info = gr.Textbox(label="GPU Information", interactive=False)
+                
+                def get_gpu_info():
+                    if torch.cuda.is_available():
+                        return f"GPU: {torch.cuda.get_device_name(0)}\nVRAM: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB\nCUDA Version: {torch.version.cuda}"
+                    else:
+                        return "No GPU detected. Using CPU mode."
+                
+                # Display GPU info on load
+                gpu_info.value = get_gpu_info()
+        
+        # Create the API endpoint
+        edit_image_api = gr.Interface(
+            fn=edit_image,
+            inputs=[
+                input_image,
+                feature_type,
+                modification_type,
+                intensity,
+                num_inference_steps,
+                guidance_scale,
+                resolution,
+                custom_prompt,
+                use_custom_prompt
+            ],
+            outputs=[output_image, status_text],
+            title="AI-Powered Facial & Body Feature Editor API",
+            description="Local GPU server API endpoint",
+            allow_flagging="never"
+        )
+    
+    return server
+
+# Launch the server
+if __name__ == "__main__":
+    # Check for GPU
+    if torch.cuda.is_available():
+        print(f"GPU detected: {torch.cuda.get_device_name(0)}")
+        print(f"VRAM: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")
+    else:
+        print("No GPU detected. Using CPU mode.")
+    
+    # Create and launch server
+    server = create_server()
+    server.queue()
+    server.launch(server_name="0.0.0.0", share=True)