Update app.py

app.py

@@ -4,160 +4,139 @@ import random
 import torch
 import gc
 from typing import Optional, Tuple
-import spaces  # For ZeroGPU support
+import warnings
+warnings.filterwarnings("ignore")
 
-# Image generation models
+# CPU-optimized imports
 from diffusers import (
-    DiffusionPipeline, StableDiffusionPipeline, 
-    StableDiffusionXLPipeline, AutoPipelineForText2Image,
-    AnimateDiffPipeline, DiffusionPipeline as VideoPipeline
+    StableDiffusionPipeline, 
+    DiffusionPipeline,
+    DDIMScheduler,
+    DPMSolverMultistepScheduler
 )
+from transformers import CLIPTokenizer
 
-device = "cuda" if torch.cuda.is_available() else "cpu"
+# Force CPU usage and optimize for low-resource environment
+device = "cpu"
+torch.set_num_threads(2)  # Match vCPU count
 MAX_SEED = np.iinfo(np.int32).max
-MAX_IMAGE_SIZE = 1024
 
-# Model configurations optimized for different hardware
+# CPU-optimized model configurations
 MODEL_CONFIGS = {
-    "Image Models": {
-        "SDXL-Turbo (Fast)": {
-            "repo_id": "stabilityai/sdxl-turbo",
-            "pipeline_class": "auto",
-            "cpu_friendly": True,
-            "vram_usage": "Low",
-            "default_steps": 2,
-            "default_guidance": 0.0,
-            "torch_dtype": torch.float16 if torch.cuda.is_available() else torch.float32
-        },
-        "SD 1.5 (CPU Optimized)": {
-            "repo_id": "runwayml/stable-diffusion-v1-5",
-            "pipeline_class": "sd15",
-            "cpu_friendly": True,
-            "vram_usage": "Low",
-            "default_steps": 20,
-            "default_guidance": 7.5,
-            "torch_dtype": torch.float32
-        },
-        "SD 2.1 (Balanced)": {
-            "repo_id": "stabilityai/stable-diffusion-2-1",
-            "pipeline_class": "sd21",
-            "cpu_friendly": False,
-            "vram_usage": "Medium",
-            "default_steps": 25,
-            "default_guidance": 7.5,
-            "torch_dtype": torch.float16 if torch.cuda.is_available() else torch.float32
-        },
-        "SDXL Base (High Quality)": {
-            "repo_id": "stabilityai/stable-diffusion-xl-base-1.0",
-            "pipeline_class": "sdxl",
-            "cpu_friendly": False,
-            "vram_usage": "High",
-            "default_steps": 30,
-            "default_guidance": 7.5,
-            "torch_dtype": torch.float16 if torch.cuda.is_available() else torch.float32
-        }
+    "🚀 Tiny SD (Ultra Fast)": {
+        "repo_id": "nota-ai/bk-sdm-small",
+        "torch_dtype": torch.float32,
+        "max_resolution": 512,
+        "default_steps": 10,
+        "default_guidance": 6.0,
+        "memory_usage": "Very Low",
+        "speed": "Ultra Fast"
     },
-    "Video Models": {
-        "AnimateDiff (Motion)": {
-            "repo_id": "guoyww/animatediff-motion-adapter-v1-5-2",
-            "pipeline_class": "animatediff",
-            "cpu_friendly": False,
-            "vram_usage": "High",
-            "default_steps": 25,
-            "default_guidance": 7.5,
-            "torch_dtype": torch.float16 if torch.cuda.is_available() else torch.float32
-        },
-        "Zeroscope v2 (Text-to-Video)": {
-            "repo_id": "cerspense/zeroscope_v2_576w",
-            "pipeline_class": "video",
-            "cpu_friendly": False,
-            "vram_usage": "Very High",
-            "default_steps": 40,
-            "default_guidance": 9.0,
-            "torch_dtype": torch.float16 if torch.cuda.is_available() else torch.float32
-        }
+    "⚡ SD 1.4 (Fast)": {
+        "repo_id": "CompVis/stable-diffusion-v1-4",
+        "torch_dtype": torch.float32,
+        "max_resolution": 512,
+        "default_steps": 15,
+        "default_guidance": 7.5,
+        "memory_usage": "Low",
+        "speed": "Fast"
+    },
+    "🎨 SD 1.5 (Balanced)": {
+        "repo_id": "runwayml/stable-diffusion-v1-5",
+        "torch_dtype": torch.float32,
+        "max_resolution": 512,
+        "default_steps": 20,
+        "default_guidance": 7.5,
+        "memory_usage": "Medium",
+        "speed": "Medium"
+    },
+    "🖼️ OpenJourney (Artistic)": {
+        "repo_id": "prompthero/openjourney",
+        "torch_dtype": torch.float32,
+        "max_resolution": 512,
+        "default_steps": 18,
+        "default_guidance": 8.0,
+        "memory_usage": "Medium",
+        "speed": "Medium"
+    },
+    "🌟 Dreamlike (Quality)": {
+        "repo_id": "dreamlike-art/dreamlike-diffusion-1.0",
+        "torch_dtype": torch.float32,
+        "max_resolution": 448,
+        "default_steps": 25,
+        "default_guidance": 8.0,
+        "memory_usage": "Medium-High",
+        "speed": "Slower"
     }
 }
 
-# Global pipeline cache
+# Global variables for memory management
 current_pipeline = None
 current_model_name = None
 
-def clear_pipeline():
-    """Clear current pipeline to free memory"""
+def clear_memory():
+    """Aggressive memory cleanup for CPU environment"""
     global current_pipeline
     if current_pipeline is not None:
         del current_pipeline
         current_pipeline = None
-        gc.collect()
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-
-def get_pipeline_class(pipeline_type: str):
-    """Get the appropriate pipeline class"""
-    if pipeline_type == "auto":
-        return AutoPipelineForText2Image
-    elif pipeline_type == "sd15":
-        return StableDiffusionPipeline
-    elif pipeline_type == "sd21":
-        return StableDiffusionPipeline
-    elif pipeline_type == "sdxl":
-        return StableDiffusionXLPipeline
-    elif pipeline_type == "animatediff":
-        return AnimateDiffPipeline
-    elif pipeline_type == "video":
-        return VideoPipeline
-    else:
-        return DiffusionPipeline
+    
+    # Force garbage collection
+    gc.collect()
+    
+    # Clear any cached models
+    torch.cuda.empty_cache() if torch.cuda.is_available() else None
 
-def load_model(model_name: str, model_type: str = "Image Models"):
-    """Load a model with memory optimization"""
+def load_model_cpu_optimized(model_name: str):
+    """Load model with maximum CPU optimization"""
     global current_pipeline, current_model_name
     
+    # Return cached pipeline if same model
     if current_model_name == model_name and current_pipeline is not None:
-        return current_pipeline
+        return current_pipeline, "✅ Using cached model"
     
     # Clear previous model
-    clear_pipeline()
-    
-    config = MODEL_CONFIGS[model_type][model_name]
-    pipeline_class = get_pipeline_class(config["pipeline_class"])
+    clear_memory()
     
     try:
-        # Load with optimizations
-        pipe = pipeline_class.from_pretrained(
+        config = MODEL_CONFIGS[model_name]
+        
+        # Load with CPU optimizations
+        pipe = StableDiffusionPipeline.from_pretrained(
             config["repo_id"],
             torch_dtype=config["torch_dtype"],
-            use_safetensors=True,
-            variant="fp16" if torch.cuda.is_available() and config["torch_dtype"] == torch.float16 else None
+            safety_checker=None,  # Disable for speed
+            requires_safety_checker=False,
+            use_safetensors=False,  # Faster loading on CPU
+            local_files_only=False
+        )
+        
+        # Apply CPU-specific optimizations
+        pipe = pipe.to(device)
+        
+        # Enable attention slicing for memory efficiency
+        pipe.enable_attention_slicing(1)
+        
+        # Use memory efficient scheduler
+        pipe.scheduler = DPMSolverMultistepScheduler.from_config(
+            pipe.scheduler.config,
+            use_karras_sigmas=True,
+            algorithm_type="dpmsolver++"
         )
         
-        # Apply optimizations based on hardware
-        if torch.cuda.is_available():
-            pipe = pipe.to(device)
-            # Enable memory efficient attention
-            if hasattr(pipe, 'enable_attention_slicing'):
-                pipe.enable_attention_slicing()
-            if hasattr(pipe, 'enable_xformers_memory_efficient_attention'):
-                try:
-                    pipe.enable_xformers_memory_efficient_attention()
-                except:
-                    pass
-        else:
-            pipe = pipe.to(device)
-            # CPU optimizations
-            if hasattr(pipe, 'enable_attention_slicing'):
-                pipe.enable_attention_slicing()
+        # Additional CPU optimizations
+        pipe.unet.to(memory_format=torch.channels_last)
+        pipe.vae.to(memory_format=torch.channels_last)
         
         current_pipeline = pipe
         current_model_name = model_name
-        return pipe
+        
+        return pipe, f"✅ {model_name} loaded successfully!"
         
     except Exception as e:
-        return f"Error loading model: {str(e)}"
+        return None, f"❌ Failed to load {model_name}: {str(e)}"
 
-@spaces.GPU(duration=60)  # ZeroGPU support
-def generate_image(
+def generate_image_cpu(
     model_name: str,
     prompt: str,
     negative_prompt: str,
@@ -171,28 +150,37 @@ def generate_image(
 ) -> Tuple[Optional[np.ndarray], int, str]:
     
     if not prompt.strip():
-        return None, seed, "Please enter a prompt"
+        return None, seed, "⚠️ Please enter a prompt"
+    
+    # Load model
+    pipe, status = load_model_cpu_optimized(model_name)
+    if pipe is None:
+        return None, seed, status
     
     try:
-        # Load model
-        pipe = load_model(model_name, "Image Models")
-        if isinstance(pipe, str):  # Error message
-            return None, seed, pipe
-        
         # Handle seed
         if randomize_seed:
             seed = random.randint(0, MAX_SEED)
         
-        generator = torch.Generator(device=device).manual_seed(seed)
+        generator = torch.Generator().manual_seed(seed)
+        
+        # CPU-specific constraints
+        config = MODEL_CONFIGS[model_name]
+        max_res = config["max_resolution"]
+        width = min(width, max_res)
+        height = min(height, max_res)
+        
+        # Ensure dimensions are multiples of 8
+        width = (width // 8) * 8
+        height = (height // 8) * 8
         
-        # Adjust parameters for CPU
-        if device == "cpu":
-            width = min(width, 512)
-            height = min(height, 512)
-            num_inference_steps = min(num_inference_steps, 20)
+        # Limit steps for CPU
+        num_inference_steps = min(num_inference_steps, 30)
         
-        # Generate image
-        with torch.autocast(device):
+        progress(0, desc="Starting generation...")
+        
+        # Generate with CPU optimizations
+        with torch.no_grad():
             result = pipe(
                 prompt=prompt,
                 negative_prompt=negative_prompt if negative_prompt.strip() else None,
@@ -201,295 +189,235 @@ def generate_image(
                 width=width,
                 height=height,
                 generator=generator,
+                callback_on_step_end=lambda step, timestep, latents: progress(step/num_inference_steps)
             )
         
         image = result.images[0]
-        return image, seed, "✅ Image generated successfully!"
-        
-    except Exception as e:
-        error_msg = f"❌ Generation failed: {str(e)}"
-        if "out of memory" in str(e).lower():
-            error_msg += "\n💡 Try: Lower resolution, fewer steps, or use a CPU-friendly model"
-        return None, seed, error_msg
-
-@spaces.GPU(duration=120)  # Longer duration for video
-def generate_video(
-    model_name: str,
-    prompt: str,
-    negative_prompt: str,
-    seed: int,
-    randomize_seed: bool,
-    num_frames: int,
-    guidance_scale: float,
-    num_inference_steps: int,
-    progress=gr.Progress(track_tqdm=True),
-) -> Tuple[Optional[str], int, str]:
-    
-    if not prompt.strip():
-        return None, seed, "Please enter a prompt"
-    
-    if device == "cpu":
-        return None, seed, "❌ Video generation requires GPU"
-    
-    try:
-        # Load model
-        pipe = load_model(model_name, "Video Models")
-        if isinstance(pipe, str):  # Error message
-            return None, seed, pipe
         
-        # Handle seed
-        if randomize_seed:
-            seed = random.randint(0, MAX_SEED)
-        
-        generator = torch.Generator(device=device).manual_seed(seed)
-        
-        # Generate video
-        with torch.autocast(device):
-            if "animatediff" in model_name.lower():
-                result = pipe(
-                    prompt=prompt,
-                    negative_prompt=negative_prompt if negative_prompt.strip() else None,
-                    num_frames=num_frames,
-                    guidance_scale=guidance_scale,
-                    num_inference_steps=num_inference_steps,
-                    generator=generator,
-                )
-                # Save as GIF
-                video_path = "output_video.gif"
-                result.export_to_gif(video_path)
-            else:
-                result = pipe(
-                    prompt=prompt,
-                    negative_prompt=negative_prompt if negative_prompt.strip() else None,
-                    num_frames=num_frames,
-                    guidance_scale=guidance_scale,
-                    num_inference_steps=num_inference_steps,
-                    generator=generator,
-                )
-                # Save as MP4
-                video_path = "output_video.mp4"
-                result.export_to_video(video_path)
+        # Memory cleanup after generation
+        del result
+        gc.collect()
         
-        return video_path, seed, "✅ Video generated successfully!"
+        return image, seed, f"✅ Generated {width}x{height} image in {num_inference_steps} steps"
         
     except Exception as e:
-        error_msg = f"❌ Video generation failed: {str(e)}"
-        if "out of memory" in str(e).lower():
-            error_msg += "\n💡 Try: Fewer frames, lower steps, or switch to image generation"
+        error_msg = f"❌ Generation failed: {str(e)}"
+        if "memory" in str(e).lower() or "out of" in str(e).lower():
+            error_msg += "\n💡 Try: Smaller resolution (256x256), fewer steps (10-15), or Tiny SD model"
         return None, seed, error_msg
 
-def get_model_defaults(model_name: str, model_type: str):
-    """Get default values for selected model"""
-    if model_type in MODEL_CONFIGS and model_name in MODEL_CONFIGS[model_type]:
-        config = MODEL_CONFIGS[model_type][model_name]
-        return config["default_steps"], config["default_guidance"]
-    return 20, 7.5
-
-# Example prompts
-image_examples = [
-    "A majestic dragon flying over a mystical forest, detailed, 8k",
-    "Cyberpunk cityscape at night, neon lights, futuristic",
-    "Portrait of a wise old wizard with glowing eyes",
-    "Serene mountain lake at sunset, photorealistic"
+# Optimized example prompts for CPU generation
+examples = [
+    "a cute cat sitting in a garden, digital art",
+    "mountain landscape at sunset, beautiful painting",
+    "portrait of a smiling person, photography",
+    "colorful flowers in a vase, oil painting",
+    "futuristic city skyline, concept art",
+    "peaceful forest path, nature photography"
 ]
 
-video_examples = [
-    "A cat walking through a magical garden",
-    "Ocean waves crashing on a beach at sunset",
-    "A butterfly flying around colorful flowers",
-    "Clouds moving across a blue sky"
-]
-
-# CSS for better styling
+# CSS optimized for CPU performance (minimal animations)
 css = """
 #col-container {
     margin: 0 auto;
-    max-width: 900px;
+    max-width: 800px;
+    padding: 20px;
 }
-.model-info {
-    padding: 10px;
-    margin: 5px 0;
-    border-radius: 5px;
-    background-color: #f0f0f0;
+.model-card {
+    padding: 15px;
+    margin: 10px 0;
+    border-radius: 8px;
+    background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+    border: 1px solid #ddd;
 }
-.status-success {
-    color: #28a745;
+.cpu-optimized {
+    background: linear-gradient(135deg, #a8edea 0%, #fed6e3 100%);
+    font-weight: bold;
 }
-.status-error {
-    color: #dc3545;
+.status-text {
+    padding: 10px;
+    border-radius: 5px;
+    margin: 10px 0;
 }
+.status-success { background-color: #d4edda; color: #155724; }
+.status-error { background-color: #f8d7da; color: #721c24; }
+.status-warning { background-color: #fff3cd; color: #856404; }
 """
 
-# Main Gradio interface
-with gr.Blocks(css=css, title="Multi-Model AI Generator") as demo:
+# Main interface optimized for CPU
+with gr.Blocks(css=css, title="CPU-Optimized AI Image Generator") as demo:
     with gr.Column(elem_id="col-container"):
-        gr.Markdown("# 🎨 Multi-Model AI Generator")
-        gr.Markdown("Generate images and videos using various AI models optimized for different hardware configurations.")
+        gr.Markdown("""
+        # 🖥️ CPU-Optimized AI Image Generator
+        ### Specially optimized for CPU Basic (2 vCPUs, 16GB RAM)
+        """)
         
-        # Hardware info
-        hardware_info = f"🖥️ **Device**: {device.upper()}"
-        if torch.cuda.is_available():
-            gpu_name = torch.cuda.get_device_name(0)
-            vram_gb = torch.cuda.get_device_properties(0).total_memory / 1e9
-            hardware_info += f" ({gpu_name}, {vram_gb:.1f}GB VRAM)"
-        gr.Markdown(hardware_info)
+        # System info
+        gr.Markdown("""
+        <div class="model-card cpu-optimized">
+        📊 <strong>System Configuration:</strong> CPU Basic | 2 vCPUs | 16GB RAM | PyTorch CPU
+        </div>
+        """)
         
-        with gr.Tabs():
-            # IMAGE GENERATION TAB
-            with gr.TabItem("🖼️ Image Generation"):
-                with gr.Row():
-                    with gr.Column(scale=3):
-                        img_prompt = gr.Text(
-                            label="Prompt",
-                            placeholder="Describe the image you want to generate...",
-                            lines=2
-                        )
-                    with gr.Column(scale=1):
-                        img_generate_btn = gr.Button("🎨 Generate Image", variant="primary", size="lg")
+        with gr.Row():
+            with gr.Column(scale=3):
+                prompt = gr.Textbox(
+                    label="✨ Your Creative Prompt",
+                    placeholder="Describe the image you want to create...",
+                    lines=3,
+                    max_lines=5
+                )
+            with gr.Column(scale=1):
+                generate_btn = gr.Button(
+                    "🎨 Generate Image", 
+                    variant="primary", 
+                    size="lg",
+                    elem_classes="generate-button"
+                )
+        
+        # Model selection with detailed info
+        with gr.Row():
+            model_dropdown = gr.Dropdown(
+                choices=list(MODEL_CONFIGS.keys()),
+                value="🚀 Tiny SD (Ultra Fast)",
+                label="🤖 AI Model Selection",
+                info="Choose based on speed vs quality preference"
+            )
+        
+        # Model info display
+        model_info_display = gr.Markdown("", elem_classes="model-card")
+        
+        # Generated image display
+        result_image = gr.Image(
+            label="🖼️ Generated Image", 
+            height=400,
+            show_label=True
+        )
+        
+        # Status display
+        status_display = gr.Markdown(
+            "🚀 Ready to generate! Select a model and enter your prompt.", 
+            elem_classes="status-text status-success"
+        )
+        
+        # Advanced settings in accordion
+        with gr.Accordion("⚙️ Advanced Settings", open=False):
+            with gr.Column():
+                negative_prompt = gr.Textbox(
+                    label="🚫 Negative Prompt (Optional)",
+                    placeholder="What you don't want in the image...",
+                    lines=2
+                )
                 
                 with gr.Row():
-                    with gr.Column(scale=2):
-                        img_model_dropdown = gr.Dropdown(
-                            choices=list(MODEL_CONFIGS["Image Models"].keys()),
-                            value="SDXL-Turbo (Fast)",
-                            label="Model",
-                            info="Choose based on your hardware capabilities"
-                        )
-                        
-                        # Model info display
-                        img_model_info = gr.Markdown("", elem_classes="model-info")
-                        
-                    with gr.Column(scale=3):
-                        img_result = gr.Image(label="Generated Image", height=400)
+                    seed = gr.Slider(0, MAX_SEED, value=0, label="🎲 Seed")
+                    randomize_seed = gr.Checkbox(label="🔄 Random Seed", value=True)
                 
-                with gr.Accordion("⚙️ Advanced Settings", open=False):
-                    with gr.Row():
-                        img_negative_prompt = gr.Text(
-                            label="Negative Prompt",
-                            placeholder="What you don't want in the image...",
-                            lines=1
-                        )
-                    
-                    with gr.Row():
-                        img_seed = gr.Slider(0, MAX_SEED, value=0, label="Seed")
-                        img_randomize_seed = gr.Checkbox(label="Random Seed", value=True)
-                    
-                    with gr.Row():
-                        img_width = gr.Slider(256, MAX_IMAGE_SIZE, value=512, step=64, label="Width")
-                        img_height = gr.Slider(256, MAX_IMAGE_SIZE, value=512, step=64, label="Height")
-                    
-                    with gr.Row():
-                        img_guidance = gr.Slider(0.0, 20.0, value=7.5, step=0.5, label="Guidance Scale")
-                        img_steps = gr.Slider(1, 50, value=20, step=1, label="Inference Steps")
-                
-                img_status = gr.Markdown("Ready to generate!", elem_classes="status-success")
-                gr.Examples(examples=image_examples, inputs=[img_prompt])
-            
-            # VIDEO GENERATION TAB
-            with gr.TabItem("🎬 Video Generation"):
                 with gr.Row():
-                    with gr.Column(scale=3):
-                        vid_prompt = gr.Text(
-                            label="Prompt",
-                            placeholder="Describe the video you want to generate...",
-                            lines=2
-                        )
-                    with gr.Column(scale=1):
-                        vid_generate_btn = gr.Button("🎬 Generate Video", variant="primary", size="lg")
+                    width = gr.Slider(
+                        256, 512, value=384, step=64, 
+                        label="📏 Width",
+                        info="Lower = faster generation"
+                    )
+                    height = gr.Slider(
+                        256, 512, value=384, step=64, 
+                        label="📐 Height",
+                        info="Lower = faster generation"
+                    )
                 
                 with gr.Row():
-                    with gr.Column(scale=2):
-                        vid_model_dropdown = gr.Dropdown(
-                            choices=list(MODEL_CONFIGS["Video Models"].keys()),
-                            value="AnimateDiff (Motion)",
-                            label="Model",
-                            info="Video generation requires GPU"
-                        )
-                        
-                        vid_model_info = gr.Markdown("", elem_classes="model-info")
-                        
-                    with gr.Column(scale=3):
-                        vid_result = gr.Video(label="Generated Video", height=400)
-                
-                with gr.Accordion("⚙️ Video Settings", open=False):
-                    with gr.Row():
-                        vid_negative_prompt = gr.Text(
-                            label="Negative Prompt",
-                            placeholder="What you don't want in the video...",
-                            lines=1
-                        )
-                    
-                    with gr.Row():
-                        vid_seed = gr.Slider(0, MAX_SEED, value=0, label="Seed")
-                        vid_randomize_seed = gr.Checkbox(label="Random Seed", value=True)
-                    
-                    with gr.Row():
-                        vid_frames = gr.Slider(8, 64, value=16, step=8, label="Number of Frames")
-                        vid_guidance = gr.Slider(1.0, 20.0, value=7.5, step=0.5, label="Guidance Scale")
-                        vid_steps = gr.Slider(10, 50, value=25, step=1, label="Inference Steps")
-                
-                vid_status = gr.Markdown("Ready to generate!", elem_classes="status-success")
-                gr.Examples(examples=video_examples, inputs=[vid_prompt])
+                    guidance_scale = gr.Slider(
+                        1.0, 15.0, value=7.5, step=0.5,
+                        label="🎯 Guidance Scale",
+                        info="How closely to follow the prompt"
+                    )
+                    num_inference_steps = gr.Slider(
+                        5, 30, value=15, step=1,
+                        label="🔄 Steps",
+                        info="More steps = better quality but slower"
+                    )
         
-        # Model info update functions
-        def update_img_model_info(model_name):
-            config = MODEL_CONFIGS["Image Models"][model_name]
-            info = f"""
-            **VRAM Usage**: {config['vram_usage']} | **CPU Friendly**: {'✅' if config['cpu_friendly'] else '❌'}
+        # CPU Performance Tips
+        with gr.Accordion("💡 CPU Optimization Tips", open=False):
+            gr.Markdown("""
+            ### 🚀 For Fastest Generation:
+            - Use **Tiny SD** model
+            - Set resolution to **256x256** or **384x384**
+            - Use **10-15 steps**
+            - Keep guidance scale around **6-8**
             
-            **Recommended Settings**: {config['default_steps']} steps, {config['default_guidance']} guidance
-            """
-            steps, guidance = get_model_defaults(model_name, "Image Models")
-            return info, steps, guidance
-        
-        def update_vid_model_info(model_name):
-            config = MODEL_CONFIGS["Video Models"][model_name]
-            info = f"""
-            **VRAM Usage**: {config['vram_usage']} | **CPU Friendly**: {'✅' if config['cpu_friendly'] else '❌'}
+            ### 🎨 For Best Quality:
+            - Use **Dreamlike** or **SD 1.5** model
+            - Set resolution to **512x512** (max)
+            - Use **20-25 steps**
+            - Guidance scale **7-9**
             
-            **Recommended Settings**: {config['default_steps']} steps, {config['default_guidance']} guidance
-            """
-            steps, guidance = get_model_defaults(model_name, "Video Models")
-            return info, steps, guidance
+            ### ⚡ Memory Saving:
+            - Generate one image at a time
+            - Use shorter prompts when possible
+            - Avoid very high guidance scales (>12)
+            """)
         
-        # Event handlers
-        img_model_dropdown.change(
-            update_img_model_info,
-            inputs=[img_model_dropdown],
-            outputs=[img_model_info, img_steps, img_guidance]
+        # Examples
+        gr.Examples(
+            examples=examples,
+            inputs=[prompt],
+            label="💡 Example Prompts (Click to try!)"
         )
         
-        vid_model_dropdown.change(
-            update_vid_model_info,
-            inputs=[vid_model_dropdown],
-            outputs=[vid_model_info, vid_steps, vid_guidance]
-        )
-        
-        # Generation event handlers
-        img_generate_btn.click(
-            generate_image,
-            inputs=[
-                img_model_dropdown, img_prompt, img_negative_prompt,
-                img_seed, img_randomize_seed, img_width, img_height,
-                img_guidance, img_steps
-            ],
-            outputs=[img_result, img_seed, img_status]
-        )
-        
-        vid_generate_btn.click(
-            generate_video,
-            inputs=[
-                vid_model_dropdown, vid_prompt, vid_negative_prompt,
-                vid_seed, vid_randomize_seed, vid_frames,
-                vid_guidance, vid_steps
-            ],
-            outputs=[vid_result, vid_seed, vid_status]
-        )
+        # Footer with helpful info
+        gr.Markdown("""
+        ---
+        <div style="text-align: center; color: #666; font-size: 0.9em;">
+        🖥️ Optimized for CPU Basic | Generation time: 30s-3min depending on settings
+        </div>
+        """)
+    
+    # Function to update model info
+    def update_model_info(model_name):
+        config = MODEL_CONFIGS[model_name]
+        info = f"""
+        <div class="model-card">
+        <strong>{model_name}</strong><br>
+        📊 <strong>Memory Usage:</strong> {config['memory_usage']} | 
+        ⚡ <strong>Speed:</strong> {config['speed']}<br>
+        📏 <strong>Max Resolution:</strong> {config['max_resolution']}px | 
+        🔄 <strong>Recommended Steps:</strong> {config['default_steps']}<br>
+        🎯 <strong>Recommended Guidance:</strong> {config['default_guidance']}
+        </div>
+        """
+        return info, config['default_steps'], config['default_guidance']
+    
+    # Event handlers
+    model_dropdown.change(
+        update_model_info,
+        inputs=[model_dropdown],
+        outputs=[model_info_display, num_inference_steps, guidance_scale]
+    )
+    
+    # Generation handler
+    generate_btn.click(
+        generate_image_cpu,
+        inputs=[
+            model_dropdown, prompt, negative_prompt,
+            seed, randomize_seed, width, height,
+            guidance_scale, num_inference_steps
+        ],
+        outputs=[result_image, seed, status_display]
+    )
+    
+    # Auto-trigger model info update on load
+    demo.load(
+        update_model_info,
+        inputs=[model_dropdown],
+        outputs=[model_info_display, num_inference_steps, guidance_scale]
+    )
 
 if __name__ == "__main__":
     demo.launch(
         share=True,
         server_name="0.0.0.0",
         server_port=7860,
-        show_error=True
+        show_error=True,
+        quiet=True
     )