Upload 5 files

DEPLOYMENT_GUIDE.md

@@ -0,0 +1,139 @@
+# Hugging Face Spaces Deployment Guide
+
+## Quick Start - Deploy to Hugging Face Spaces
+
+### Option 1: Web Upload (Easiest)
+
+1. **Create a New Space**
+   - Go to https://huggingface.co/new-space
+   - Name your space (e.g., "stable-diffusion-style-explorer")
+   - Select **Gradio** as the SDK
+   - Choose your preferred visibility (Public/Private)
+   - Click "Create Space"
+
+2. **Upload Files**
+   - Click "Files" tab in your new Space
+   - Click "Add file" → "Upload files"
+   - Upload these files from `hf_app/` folder:
+     - `app.py`
+     - `requirements.txt`
+     - `README.md`
+   - Click "Commit changes to main"
+
+3. **Wait for Build**
+   - The Space will automatically build (takes 5-10 minutes first time)
+   - You'll see build logs in the "Logs" tab
+   - Once complete, your app will be live!
+
+### Option 2: Git Push (Advanced)
+
+```bash
+# Navigate to the hf_app directory
+cd C:\Users\sidhe\TSAIV4\Session15-Assignment\hf_app
+
+# Initialize git (if not already done)
+git init
+
+# Add Hugging Face Space as remote
+# Replace YOUR_USERNAME and YOUR_SPACE_NAME
+git remote add origin https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+
+# Add and commit files
+git add .
+git commit -m "Initial commit: Stable Diffusion Style Explorer"
+
+# Push to Hugging Face
+git push origin main
+```
+
+## Local Testing (Optional)
+
+Test the app locally before deploying:
+
+```bash
+# Navigate to hf_app directory
+cd C:\Users\sidhe\TSAIV4\Session15-Assignment\hf_app
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the app
+python app.py
+```
+
+The app will open at `http://localhost:7860`
+
+## Hardware Requirements
+
+### For Hugging Face Spaces:
+- **Free Tier (CPU)**: Works but slow (~2-3 minutes per image)
+- **Upgraded (GPU)**: Recommended for production
+  - T4 GPU: ~10-15 seconds per image
+  - A10G GPU: ~5-8 seconds per image
+
+### To Upgrade Space Hardware:
+1. Go to your Space settings
+2. Click "Hardware" tab
+3. Select GPU tier (requires payment)
+
+## Troubleshooting
+
+### Build Fails
+- Check `requirements.txt` versions are compatible
+- Review build logs in Spaces "Logs" tab
+- Ensure all imports in `app.py` are in `requirements.txt`
+
+### Out of Memory
+- Reduce `num_inference_steps` default value
+- Use CPU instead of GPU (slower but more memory)
+- Upgrade to larger GPU tier
+
+### Slow Generation
+- Upgrade to GPU hardware
+- Reduce inference steps (trade quality for speed)
+- Consider caching the pipeline
+
+## Customization
+
+### Add More Styles
+Edit `app.py` and add to the `STYLES` dictionary:
+
+```python
+STYLES = {
+    # ... existing styles ...
+    "Your Style Name": {
+        "repo": "sd-concepts-library/your-concept",
+        "token": "<your-token>",
+        "description": "Your style description"
+    }
+}
+```
+
+### Change Base Model
+Replace in `app.py`:
+```python
+pipe = StableDiffusionPipeline.from_pretrained(
+    "runwayml/stable-diffusion-v1-5",  # or another model
+    torch_dtype=dtype,
+    safety_checker=None
+).to(device)
+```
+
+### Adjust Default Parameters
+Modify the default values in the Gradio components:
+- `steps_single = gr.Slider(..., value=30, ...)` - Change default steps
+- `guidance_single = gr.Slider(..., value=7.5, ...)` - Change guidance scale
+
+## Next Steps
+
+1. ✅ Deploy to Hugging Face Spaces
+2. ✅ Test with different prompts and styles
+3. ✅ Share your Space URL with others
+4. ✅ Monitor usage in Space analytics
+5. ✅ Iterate based on user feedback
+
+## Support
+
+- Hugging Face Spaces Docs: https://huggingface.co/docs/hub/spaces
+- Gradio Documentation: https://gradio.app/docs
+- Diffusers Documentation: https://huggingface.co/docs/diffusers

QUICKSTART.md

@@ -0,0 +1,83 @@
+# Quick Start Guide - Local Testing
+
+## Installation Complete! ✅
+
+All dependencies have been installed successfully. Here's what to do next:
+
+## Running the App
+
+### Option 1: Simple Run
+```bash
+python app.py
+```
+
+The app will start and show you a URL like:
+```
+Running on local URL:  http://127.0.0.1:7860
+```
+
+Open that URL in your browser!
+
+### Option 2: Share Publicly (Temporary)
+```bash
+# Edit app.py, change the last line to:
+demo.launch(share=True)
+```
+
+This creates a temporary public URL you can share with others.
+
+## What to Expect
+
+### First Run
+- The app will download the Stable Diffusion model (~4GB)
+- This happens only once - subsequent runs are fast
+- Download location: `~/.cache/huggingface/`
+
+### Performance
+- **With GPU (CUDA)**: ~10-15 seconds per image
+- **Without GPU (CPU)**: ~2-3 minutes per image
+
+Check if CUDA is available:
+```bash
+python -c "import torch; print(f'CUDA available: {torch.cuda.is_available()}')"
+```
+
+## Using the App
+
+### Single Style Tab
+1. Enter a prompt (use `<style>` as placeholder)
+   - Example: `"a portrait of a warrior in <style>"`
+2. Select a style from dropdown
+3. Set seed (e.g., 42)
+4. Click "Generate Image"
+
+### Compare All Styles Tab
+1. Enter a prompt with `<style>` placeholder
+2. Set base seed (e.g., 100)
+3. Click "Generate All Styles"
+4. See all 5 styles side-by-side!
+
+## Troubleshooting
+
+### "Out of Memory" Error
+- Reduce inference steps to 20-30
+- Close other GPU applications
+- Use CPU mode (slower but works)
+
+### Slow Generation
+- This is normal on CPU
+- Consider using GPU for faster results
+- Reduce inference steps for speed
+
+### Model Download Fails
+- Check internet connection
+- Ensure ~5GB free disk space
+- Try again - downloads resume automatically
+
+## Next Steps
+
+1. ✅ Test the app locally
+2. ✅ Try different prompts and styles
+3. ✅ Deploy to Hugging Face Spaces (see DEPLOYMENT_GUIDE.md)
+
+Enjoy your Stable Diffusion Style Explorer! 🎨

README.md

@@ -1,13 +1,78 @@
----
-title: SDConcepts
-emoji: 🏆
-colorFrom: blue
-colorTo: yellow
-sdk: gradio
-sdk_version: 6.2.0
-app_file: app.py
-pinned: false
-short_description: An interactive web application for exploring different style
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Stable Diffusion Style Explorer
+emoji: 🎨
+colorFrom: purple
+colorTo: pink
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# Stable Diffusion Style Explorer
+
+An interactive web application for exploring different artistic styles using Stable Diffusion with textual inversion.
+
+## Features
+
+- **5 Pre-configured Styles**: Cat Toy, GTA5 Artwork, Birb Style, Midjourney Style, and Arcane Style
+- **Single Style Mode**: Generate images with a specific style, custom seed, and parameters
+- **Compare All Styles**: Generate the same prompt across all 5 styles simultaneously
+- **Seed Control**: Full control over random seeds for reproducible results
+- **Adjustable Parameters**: Configure inference steps and guidance scale
+
+## Usage
+
+### Single Style Mode
+1. Enter your prompt (use `<style>` as a placeholder for the style token)
+2. Select a style from the dropdown
+3. Set your desired seed value
+4. Adjust inference steps and guidance scale if needed
+5. Click "Generate Image"
+
+### Compare All Styles Mode
+1. Enter your prompt (use `<style>` as a placeholder)
+2. Set a base seed value
+3. Each style will use: `base_seed + (style_index * 100)`
+4. Click "Generate All Styles" to see all variations
+
+## Styles
+
+- **Cat Toy**: Cute cat toy aesthetic
+- **GTA5 Artwork**: GTA V game art style
+- **Birb Style**: Artistic bird illustration style
+- **Midjourney Style**: Midjourney AI art aesthetic
+- **Arcane Style**: Arcane Netflix series art style
+
+## Technical Details
+
+- **Base Model**: CompVis/stable-diffusion-v1-4
+- **Textual Inversion**: Concepts from [SD Concepts Library](https://huggingface.co/sd-concepts-library)
+- **Framework**: Gradio + Diffusers
+- **GPU**: Recommended for faster generation
+
+## Local Development
+
+```bash
+# Clone the repository
+git clone <your-repo-url>
+cd <repo-name>
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the app
+python app.py
+```
+
+## Deployment to Hugging Face Spaces
+
+1. Create a new Space on Hugging Face
+2. Select "Gradio" as the SDK
+3. Upload `app.py`, `requirements.txt`, and `README.md`
+4. The app will automatically build and deploy
+
+## License
+
+MIT License - Feel free to use and modify!

app.py

@@ -0,0 +1,503 @@
+import gradio as gr
+import torch
+from diffusers import StableDiffusionPipeline
+import os
+
+# Monkeypatch fixes for environment compatibility
+def apply_patches():
+    """Apply necessary patches for tqdm and symlinks"""
+    import sys
+    import shutil
+    
+    # 1. Fix tqdm Jupyter/Thread Error
+    try:
+        import tqdm
+        if not hasattr(tqdm, '_is_patched'):
+            import tqdm.notebook
+            import tqdm.std
+            tqdm.notebook.tqdm = tqdm.std.tqdm
+            tqdm.notebook.trange = tqdm.std.trange
+            if 'tqdm.auto' in sys.modules:
+                sys.modules['tqdm.auto'].tqdm = tqdm.std.tqdm
+                sys.modules['tqdm.auto'].trange = tqdm.std.trange
+            tqdm._is_patched = True
+    except ImportError:
+        pass
+    
+    # 2. Fix Windows Symlink Permissions
+    try:
+        from huggingface_hub import file_download
+        if not hasattr(file_download, '_original_create_symlink'):
+            file_download._original_create_symlink = file_download._create_symlink
+            
+            def patched_create_symlink(src, dst, new_blob=False):
+                try:
+                    file_download._original_create_symlink(src, dst, new_blob)
+                except OSError as e:
+                    if getattr(e, 'winerror', 0) == 1314:
+                        if os.path.isdir(src):
+                            shutil.copytree(src, dst)
+                        else:
+                            shutil.copy2(src, dst)
+                    else:
+                        raise
+            
+            file_download._create_symlink = patched_create_symlink
+    except ImportError:
+        pass
+
+# Apply patches before loading models
+apply_patches()
+
+# Style configurations with default seeds
+STYLES = {
+    "Cat Toy": {
+        "repo": "sd-concepts-library/cat-toy",
+        "token": "<cat-toy>",
+        "description": "Cute cat toy aesthetic",
+        "default_seed": 42
+    },
+    "Seletti": {
+        "repo": "sd-concepts-library/seletti",
+        "token": "<seletti>",
+        "description": "Seletti design style",
+        "default_seed": 142
+    },
+    "Madhubani Art": {
+        "repo": "sd-concepts-library/madhubani-art",
+        "token": "<madhubani-art>",
+        "description": "Traditional Indian Madhubani art style",
+        "default_seed": 242
+    },
+    "Chucky": {
+        "repo": "sd-concepts-library/chucky",
+        "token": "<chucky>",
+        "description": "Chucky horror character style",
+        "default_seed": 342
+    },
+    "Indian Watercolor Portraits": {
+        "repo": "sd-concepts-library/indian-watercolor-portraits",
+        "token": "<indian-watercolor-portraits>",
+        "description": "Indian watercolor portrait art style",
+        "default_seed": 442
+    },
+    "Anime Boy": {
+        "repo": "sd-concepts-library/anime-boy",
+        "token": "<anime-boy>",
+        "description": "Anime boy character style",
+        "default_seed": 542
+    }
+}
+
+# Global pipeline variable
+pipe = None
+current_style = None
+
+def contrast_loss(images):
+    """Calculate High-Contrast loss (maximizes variance/extremes)"""
+    return -torch.mean((images - 0.5) ** 2)
+
+def complexity_loss(images):
+    """Calculate Complexity loss (maximizes local detail/edges)"""
+    diff_h = torch.abs(images[:, :, 1:, :] - images[:, :, :-1, :])
+    diff_v = torch.abs(images[:, :, :, 1:] - images[:, :, :, :-1])
+    return torch.mean(diff_h) + torch.mean(diff_v)
+
+def vibrancy_loss(images):
+    """Calculate Vibrancy loss (maximizes color saturation/variety)"""
+    # Maximize standard deviation across color channels
+    # Or boost the distance from grayscale
+    means = torch.mean(images, dim=1, keepdim=True)
+    return -torch.mean((images - means) ** 2)
+
+def custom_sampling_loop(prompt, pipe, guidance_scale=7.5, contrast_scale=0.0, complexity_scale=0.0, vibrancy_scale=0.0, num_inference_steps=50, generator=None, num_images=1):
+    device = pipe.device
+    dtype = pipe.unet.dtype
+    text_input = pipe.tokenizer([prompt] * num_images, padding="max_length", max_length=pipe.tokenizer.model_max_length, truncation=True, return_tensors="pt")
+    text_embeddings = pipe.text_encoder(text_input.input_ids.to(device))[0]
+    uncond_input = pipe.tokenizer([""] * num_images, padding="max_length", max_length=text_input.input_ids.shape[-1], return_tensors="pt")
+    uncond_embeddings = pipe.text_encoder(uncond_input.input_ids.to(device))[0]
+    text_embeddings = torch.cat([uncond_embeddings, text_embeddings])
+    latents = torch.randn((num_images, pipe.unet.config.in_channels, 512 // 8, 512 // 8), generator=generator, device=device, dtype=dtype)
+    pipe.scheduler.set_timesteps(num_inference_steps)
+    latents = latents * pipe.scheduler.init_noise_sigma
+    import tqdm
+    for t in tqdm.auto.tqdm(pipe.scheduler.timesteps):
+        latent_model_input = torch.cat([latents] * 2)
+        latent_model_input = pipe.scheduler.scale_model_input(latent_model_input, t)
+        with torch.no_grad():
+            noise_pred = pipe.unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample
+        noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
+        noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
+        
+        # COMBINED GUIDANCE GRADIENT STEP
+        if contrast_scale > 0 or complexity_scale > 0 or vibrancy_scale > 0:
+            latents = latents.detach().requires_grad_(True)
+            image = pipe.vae.decode(1 / 0.18215 * latents).sample
+            image = (image / 2 + 0.5).clamp(0, 1)
+            
+            loss = 0
+            if contrast_scale > 0:
+                loss = loss + contrast_loss(image) * contrast_scale
+            if complexity_scale > 0:
+                loss = loss - complexity_loss(image) * complexity_scale
+            if vibrancy_scale > 0:
+                loss = loss + vibrancy_loss(image) * vibrancy_scale
+            
+            cond_grad = torch.autograd.grad(loss, latents)[0]
+            latents = latents.detach() - cond_grad
+            
+        latents = pipe.scheduler.step(noise_pred, t, latents).prev_sample
+    with torch.no_grad():
+        image = pipe.vae.decode(1 / 0.18215 * latents).sample
+    image = (image / 2 + 0.5).clamp(0, 1)
+    image = image.cpu().permute(0, 2, 3, 1).numpy()
+    return pipe.numpy_to_pil(image)
+
+def initialize_pipeline():
+    """Initialize the Stable Diffusion pipeline"""
+    global pipe
+    
+    if pipe is None:
+        print("Loading Stable Diffusion pipeline...")
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        dtype = torch.float16 if device == "cuda" else torch.float32
+        
+        pipe = StableDiffusionPipeline.from_pretrained(
+            "CompVis/stable-diffusion-v1-4",
+            torch_dtype=dtype,
+            use_safetensors=True,
+            safety_checker=None
+        ).to(device)
+        
+        # Performance optimizations
+        if device == "cuda":
+            pipe.enable_attention_slicing()
+            # Try to use xformers if available
+            try:
+                pipe.enable_xformers_memory_efficient_attention()
+                print("xformers enabled")
+            except Exception:
+                pass
+        
+        print(f"Pipeline loaded on {device} with dtype {dtype}")
+    
+    return pipe
+
+def load_style(style_name):
+    """Load a textual inversion style"""
+    global current_style, pipe
+    
+    if pipe is None:
+        initialize_pipeline()
+    
+    if style_name != current_style:
+        style_config = STYLES[style_name]
+        print(f"Loading style: {style_name}")
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        
+        # Load the inversion
+        pipe.load_textual_inversion(style_config["repo"])
+        
+        # Crucial: move back to device as load_textual_inversion 
+        # can sometimes mess with device placement of embeddings
+        pipe.to(device)
+        
+        current_style = style_name
+        print(f"Style loaded and verified on {device}")
+
+def generate_image(prompt, style_name, seed, num_inference_steps, guidance_scale, contrast_scale, complexity_scale, vibrancy_scale, num_images=3):
+    """Generate multiple images with the selected style"""
+    try:
+        load_style(style_name)
+        style_token = STYLES[style_name]["token"]
+        final_prompt = prompt.replace("<style>", style_token)
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        pipe.to(device)
+        generator = torch.Generator(device=device).manual_seed(seed)
+        print(f"Generating {num_images} images: '{final_prompt}' with seed {seed}, contrast {contrast_scale}, complexity {complexity_scale}, vibrancy {vibrancy_scale}")
+        if contrast_scale > 0 or complexity_scale > 0 or vibrancy_scale > 0:
+            images = custom_sampling_loop(final_prompt, pipe, guidance_scale=guidance_scale, contrast_scale=contrast_scale, complexity_scale=complexity_scale, vibrancy_scale=vibrancy_scale, num_inference_steps=num_inference_steps, generator=generator, num_images=int(num_images))
+        else:
+            result = pipe([final_prompt] * int(num_images), num_inference_steps=num_inference_steps, guidance_scale=guidance_scale, generator=generator)
+            images = result.images
+        info_text = f"**Style:** {style_name}\n**Seed:** {seed}\n**Prompt:** {final_prompt}\n**Contrast:** {contrast_scale}\n**Complexity:** {complexity_scale}\n**Vibrancy:** {vibrancy_scale}\n**Images Generated:** {len(images)}"
+        return images, info_text
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return None, f"Error: {str(e)}"
+
+def get_default_seed(style_name):
+    """Get the default seed for a specific style"""
+    return STYLES[style_name]["default_seed"]
+
+def generate_all_styles(prompt, seed1, seed2, seed3, seed4, seed5, seed6, num_inference_steps, guidance_scale, contrast_scale, complexity_scale, vibrancy_scale, num_images_per_style):
+    """Generate multiple images for all 6 styles with individual seeds"""
+    all_images = []
+    info_texts = []
+    seeds = [seed1, seed2, seed3, seed4, seed5, seed6]
+    for idx, (style_name, seed) in enumerate(zip(STYLES.keys(), seeds)):
+        style_images, info = generate_image(prompt, style_name, int(seed), num_inference_steps, guidance_scale, contrast_scale=contrast_scale, complexity_scale=complexity_scale, vibrancy_scale=vibrancy_scale, num_images=num_images_per_style)
+        all_images.append(style_images)
+        info_texts.append(info)
+    return all_images[0], all_images[1], all_images[2], all_images[3], all_images[4], all_images[5], "\n\n---\n\n".join(info_texts)
+
+# Create Gradio interface
+with gr.Blocks(title="Stable Diffusion Style Explorer", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🎨 Stable Diffusion Style Explorer
+    
+    Generate images using different textual inversion styles from the SD Concepts Library.
+    
+    **Tip:** Use `<style>` in your prompt as a placeholder - it will be replaced with the appropriate style token.
+    """)
+    
+    with gr.Tabs():
+        # Tab 1: Single Style Generation
+        with gr.Tab("Single Style"):
+            with gr.Row():
+                with gr.Column():
+                    prompt_single = gr.Textbox(
+                        label="Prompt",
+                        placeholder="a grafitti in a favela wall with a <style> on it",
+                        value="a grafitti in a favela wall with a <style>  on it",
+                        lines=3
+                    )
+                    
+                    style_dropdown = gr.Dropdown(
+                        choices=list(STYLES.keys()),
+                        value=list(STYLES.keys())[0],
+                        label="Select Style"
+                    )
+                    
+                    with gr.Row():
+                        seed_single = gr.Number(
+                            label="Seed",
+                            value=STYLES[list(STYLES.keys())[0]]["default_seed"],
+                            precision=0
+                        )
+                        
+                        steps_single = gr.Slider(
+                            minimum=10,
+                            maximum=100,
+                            value=50,
+                            step=1,
+                            label="Inference Steps"
+                        )
+                    
+                        guidance_single = gr.Slider(
+                            minimum=1,
+                            maximum=20,
+                            value=7.5,
+                            step=0.5,
+                            label="Guidance Scale"
+                        )
+                        
+                        with gr.Column(variant="panel"):
+                            gr.Markdown("### 🎨 Loss Functions")
+                            contrast_single = gr.Slider(
+                                minimum=0,
+                                maximum=2000,
+                                value=0,
+                                step=50,
+                                label="Contrast Strength",
+                                info="Steer generation towards higher contrast"
+                            )
+                            
+                            complexity_single = gr.Slider(
+                                minimum=0,
+                                maximum=2000,
+                                value=0,
+                                step=50,
+                                label="Complexity Strength",
+                                info="Steer generation towards higher detail/edges"
+                            )
+                            
+                            vibrancy_single = gr.Slider(
+                                minimum=0,
+                                maximum=2000,
+                                value=0,
+                                step=50,
+                                label="Vibrancy Strength",
+                                info="Steer generation towards higher saturation"
+                            )
+                        
+                        num_images_single = gr.Slider(
+                            minimum=1,
+                            maximum=4,
+                            value=3,
+                            step=1,
+                            label="Number of Images"
+                        )
+                    
+                    generate_btn = gr.Button("Generate Images", variant="primary")
+                
+                with gr.Column():
+                    output_gallery = gr.Gallery(label="Generated Images", show_label=False, elem_id="gallery", columns=[3], rows=[1], object_fit="contain", height="auto")
+                    output_info = gr.Markdown()
+            
+            # Update seed when style changes
+            style_dropdown.change(
+                fn=get_default_seed,
+                inputs=[style_dropdown],
+                outputs=[seed_single]
+            )
+            
+            generate_btn.click(
+                fn=generate_image,
+                inputs=[prompt_single, style_dropdown, seed_single, steps_single, guidance_single, contrast_single, complexity_single, vibrancy_single, num_images_single],
+                outputs=[output_gallery, output_info]
+            )
+        
+        # Tab 2: All Styles Comparison
+        with gr.Tab("Compare All Styles"):
+            gr.Markdown("""
+            Generate the same prompt across all 6 styles.
+            
+            **Default seeds** are pre-configured for each style, but you can override them below.
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    prompt_all = gr.Textbox(
+                        label="Prompt",
+                        placeholder="a grafitti in a favela wall with a <style>  on it",
+                        value="a grafitti in a favela wall with a <style>  on it",
+                        lines=3
+                    )
+                    
+                    gr.Markdown("### 🎲 Seed Configuration")
+                    gr.Markdown("*Each style has a default seed. Override below if desired.*")
+                    
+                    style_names = list(STYLES.keys())
+                    with gr.Row():
+                        seed1 = gr.Number(
+                            label=f"🎨 {style_names[0]} Seed",
+                            value=STYLES[style_names[0]]["default_seed"],
+                            precision=0,
+                            info=f"Default: {STYLES[style_names[0]]['default_seed']}"
+                        )
+                        seed2 = gr.Number(
+                            label=f"🎨 {style_names[1]} Seed",
+                            value=STYLES[style_names[1]]["default_seed"],
+                            precision=0,
+                            info=f"Default: {STYLES[style_names[1]]['default_seed']}"
+                        )
+                    
+                    with gr.Row():
+                        seed3 = gr.Number(
+                            label=f"🎨 {style_names[2]} Seed",
+                            value=STYLES[style_names[2]]["default_seed"],
+                            precision=0,
+                            info=f"Default: {STYLES[style_names[2]]['default_seed']}"
+                        )
+                        seed4 = gr.Number(
+                            label=f"🎨 {style_names[3]} Seed",
+                            value=STYLES[style_names[3]]["default_seed"],
+                            precision=0,
+                            info=f"Default: {STYLES[style_names[3]]['default_seed']}"
+                        )
+                    
+                    with gr.Row():
+                        seed5 = gr.Number(
+                            label=f"🎨 {style_names[4]} Seed",
+                            value=STYLES[style_names[4]]["default_seed"],
+                            precision=0,
+                            info=f"Default: {STYLES[style_names[4]]['default_seed']}"
+                        )
+                        seed6 = gr.Number(
+                            label=f"🎨 {style_names[5]} Seed",
+                            value=STYLES[style_names[5]]["default_seed"],
+                            precision=0,
+                            info=f"Default: {STYLES[style_names[5]]['default_seed']}"
+                        )
+                    
+                    steps_all = gr.Slider(
+                        minimum=10,
+                        maximum=100,
+                        value=50,
+                        step=1,
+                        label="Inference Steps"
+                    )
+                    
+                    guidance_all = gr.Slider(
+                        minimum=1,
+                        maximum=20,
+                        value=7.5,
+                        step=0.5,
+                        label="Guidance Scale"
+                    )
+
+                    with gr.Column(variant="panel"):
+                        gr.Markdown("### 🎨 Loss Functions")
+                        contrast_all = gr.Slider(
+                            minimum=0,
+                            maximum=2000,
+                            value=0,
+                            step=50,
+                            label="Contrast Strength",
+                            info="Steer generation towards higher contrast"
+                        )
+
+                        complexity_all = gr.Slider(
+                            minimum=0,
+                            maximum=2000,
+                            value=0,
+                            step=50,
+                            label="Complexity Strength",
+                            info="Steer generation towards higher detail/edges"
+                        )
+                        
+                        vibrancy_all = gr.Slider(
+                            minimum=0,
+                            maximum=2000,
+                            value=0,
+                            step=50,
+                            label="Vibrancy Strength",
+                            info="Steer generation towards higher saturation"
+                        )
+                    
+                    num_images_all = gr.Slider(
+                        minimum=1,
+                        maximum=4,
+                        value=3,
+                        step=1,
+                        label="Number of Images per Style"
+                    )
+                    
+                    generate_all_btn = gr.Button("Generate All Styles", variant="primary")
+            
+            with gr.Row():
+                style_names = list(STYLES.keys())
+                output1 = gr.Gallery(label=style_names[0], columns=[3], object_fit="contain", height="auto")
+                output2 = gr.Gallery(label=style_names[1], columns=[3], object_fit="contain", height="auto")
+                output3 = gr.Gallery(label=style_names[2], columns=[3], object_fit="contain", height="auto")
+            
+            with gr.Row():
+                output4 = gr.Gallery(label=style_names[3], columns=[3], object_fit="contain", height="auto")
+                output5 = gr.Gallery(label=style_names[4], columns=[3], object_fit="contain", height="auto")
+                output6 = gr.Gallery(label=style_names[5], columns=[3], object_fit="contain", height="auto")
+            
+            output_info_all = gr.Markdown()
+            
+            generate_all_btn.click(
+                fn=generate_all_styles,
+                inputs=[prompt_all, seed1, seed2, seed3, seed4, seed5, seed6, steps_all, guidance_all, contrast_all, complexity_all, vibrancy_all, num_images_all],
+                outputs=[output1, output2, output3, output4, output5, output6, output_info_all]
+            )
+    
+    gr.Markdown("""
+    ---
+    ### 📚 Available Styles
+    """)
+    
+    for style_name, config in STYLES.items():
+        gr.Markdown(f"**{style_name}**: {config['description']} | Token: `{config['token']}` | Default Seed: `{config['default_seed']}`")
+
+# Initialize pipeline on startup
+initialize_pipeline()
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(share=False)

requirements.txt

@@ -0,0 +1,9 @@
+gradio
+torch
+torchvision
+diffusers
+transformers
+accelerate
+huggingface-hub>=0.34.0,<1.0
+Pillow
+safetensors