Upload folder using huggingface_hub

app.py

@@ -0,0 +1,351 @@
+import gradio as gr
+import torch
+import numpy as np
+from PIL import Image
+from typing import Optional, Tuple, List
+import time
+import json
+from pathlib import Path
+
+# Mock implementation for demonstration - replace with actual Qwen model loading
+class QwenImageLightingModel:
+    """Mock Qwen Image model with lighting LoRA - replace with actual implementation"""
+    
+    def __init__(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model_loaded = False
+        
+    def load_model(self):
+        """Load the actual Qwen model and LoRA weights"""
+        # In production, load actual model here
+        # Example: self.pipeline = AutoPipelineForText2Image.from_pretrained(...)
+        # self.pipeline.load_lora_weights("path/to/lighting-lora")
+        self.model_loaded = True
+        
+    def generate_with_progressive_latents(
+        self,
+        prompt: str,
+        negative_prompt: Optional[str] = None,
+        num_inference_steps: int = 50,
+        guidance_scale: float = 7.5,
+        seed: Optional[int] = None,
+        width: int = 512,
+        height: int = 512
+    ) -> Tuple[Image.Image, List[Image.Image]]:
+        """
+        Generate image with progressive latent space sampling
+        First half: smaller latent space
+        Second half: full latent space
+        """
+        if not self.model_loaded:
+            self.load_model()
+            
+        # Mock generation - replace with actual implementation
+        progress_images = []
+        
+        # Simulate progressive generation
+        for i in range(num_inference_steps):
+            # First half: smaller latent space (simulated)
+            if i < num_inference_steps // 2:
+                progress = (i / (num_inference_steps // 2)) * 0.5
+                # In production: sample in smaller latent space
+                size = int(min(width, height) * 0.5)
+            else:
+                progress = 0.5 + ((i - num_inference_steps // 2) / (num_inference_steps // 2)) * 0.5
+                # In production: switch to full latent space
+                size = min(width, height)
+            
+            # Create mock progress image
+            mock_image = Image.fromarray(
+                np.random.randint(0, 255, (size, size, 3), dtype=np.uint8)
+            )
+            progress_images.append(mock_image)
+            
+            # Simulate processing time
+            time.sleep(0.1)
+        
+        # Final image (mock)
+        final_image = Image.fromarray(
+            np.random.randint(0, 255, (height, width, 3), dtype=np.uint8)
+        )
+        
+        return final_image, progress_images
+
+# Initialize model
+model = QwenImageLightingModel()
+
+def generate_image(
+    prompt: str,
+    negative_prompt: str = "",
+    num_inference_steps: int = 50,
+    guidance_scale: float = 7.5,
+    seed: int = -1,
+    width: int = 512,
+    height: int = 512,
+    progress: gr.Progress = gr.Progress()
+) -> Tuple[Optional[Image.Image], Optional[Image.Image]]:
+    """Generate image with progressive latent space sampling"""
+    
+    try:
+        if not prompt.strip():
+            raise gr.Error("Please enter a prompt")
+        
+        # Set seed
+        if seed == -1:
+            seed = np.random.randint(0, 2**32 - 1)
+        
+        progress(0.1, desc="Initializing model...")
+        
+        # Generate with progressive latents
+        final_image, progress_images = model.generate_with_progressive_latents(
+            prompt=prompt,
+            negative_prompt=negative_prompt if negative_prompt.strip() else None,
+            num_inference_steps=num_inference_steps,
+            guidance_scale=guidance_scale,
+            seed=seed,
+            width=width,
+            height=height
+        )
+        
+        progress(0.5, desc="Generating with progressive latents...")
+        
+        # Create a combined progress visualization
+        progress(0.9, desc="Finalizing image...")
+        
+        # Create progress grid (simplified - in production show actual progress)
+        progress_grid = create_progress_grid(progress_images)
+        
+        progress(1.0, desc="Complete!")
+        
+        return final_image, progress_grid
+        
+    except Exception as e:
+        gr.Error(f"Generation failed: {str(e)}")
+        return None, None
+
+def create_progress_grid(images: List[Image.Image]) -> Image.Image:
+    """Create a grid showing generation progress"""
+    if not images:
+        return Image.new('RGB', (512, 512), color='white')
+    
+    # Sample images for grid (every nth image)
+    sample_step = max(1, len(images) // 8)
+    sampled_images = images[::sample_step][:8]
+    
+    # Create grid
+    grid_width = len(sampled_images) * 64
+    grid_height = 64
+    grid = Image.new('RGB', (grid_width, grid_height), color='white')
+    
+    for i, img in enumerate(sampled_images):
+        # Resize to fit grid
+        resized = img.resize((64, 64), Image.Resampling.LANCZOS)
+        grid.paste(resized, (i * 64, 0))
+    
+    return grid
+
+def update_info():
+    """Update model info"""
+    info = {
+        "Model": "Qwen-Image with Lighting LoRA",
+        "Sampling": "Progressive Latent Space",
+        "Device": model.device,
+        "Status": "Ready" if model.model_loaded else "Not Loaded"
+    }
+    return json.dumps(info, indent=2)
+
+# Custom CSS for better styling
+custom_css = """
+.progress-container {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    border-radius: 10px;
+    padding: 20px;
+    margin: 10px 0;
+}
+.image-container {
+    border: 2px solid #e1e5e9;
+    border-radius: 10px;
+    padding: 10px;
+    background: white;
+}
+.main-header {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+}
+"""
+
+# Create Gradio interface
+with gr.Blocks() as demo:
+    # Header
+    gr.HTML("""
+    <div style="text-align: center; margin-bottom: 30px;">
+        <h1 class="main-header" style="font-size: 2.5em; font-weight: bold; margin-bottom: 10px;">
+            Qwen-Image with Lighting LoRA
+        </h1>
+        <p style="font-size: 1.1em; color: #666;">
+            Progressive Latent Space Sampling • First half: 50% latent size • Second half: Full latent size
+        </p>
+        <p style="font-size: 0.9em; margin-top: 10px;">
+            <a href="https://huggingface.co/spaces/akhaliq/anycoder" target="_blank" style="color: #667eea;">
+                Built with anycoder
+            </a>
+        </p>
+    </div>
+    """)
+    
+    with gr.Row():
+        # Left column - Controls
+        with gr.Column(scale=1):
+            gr.Markdown("### Generation Settings")
+            
+            # Basic inputs
+            prompt = gr.Textbox(
+                label="Prompt",
+                placeholder="Describe the image you want to generate...",
+                lines=3,
+                max_lines=5
+            )
+            
+            negative_prompt = gr.Textbox(
+                label="Negative Prompt",
+                placeholder="What to avoid in the image...",
+                lines=2,
+                max_lines=3
+            )
+            
+            # Advanced settings in accordion
+            with gr.Accordion("Advanced Settings", open=False):
+                with gr.Row():
+                    num_steps = gr.Slider(
+                        label="Inference Steps",
+                        minimum=20,
+                        maximum=100,
+                        value=50,
+                        step=1,
+                        info="More steps = better quality"
+                    )
+                    
+                    guidance_scale = gr.Slider(
+                        label="Guidance Scale",
+                        minimum=1.0,
+                        maximum=20.0,
+                        value=7.5,
+                        step=0.5,
+                        info="Higher = more prompt adherence"
+                    )
+                
+                with gr.Row():
+                    width = gr.Dropdown(
+                        label="Width",
+                        choices=[256, 512, 768, 1024],
+                        value=512
+                    )
+                    
+                    height = gr.Dropdown(
+                        label="Height",
+                        choices=[256, 512, 768, 1024],
+                        value=512
+                    )
+                
+                seed = gr.Number(
+                    label="Seed (-1 for random)",
+                    value=-1,
+                    precision=0
+                )
+            
+            # Generate button
+            generate_btn = gr.Button(
+                "Generate Image",
+                variant="primary",
+                size="lg",
+                elem_classes=["generate-button"]
+            )
+            
+            # Model info
+            with gr.Accordion("Model Information", open=False):
+                model_info = gr.JSON(label="Model Status")
+                update_info_btn = gr.Button("Refresh Status", size="sm")
+        
+        # Right column - Outputs
+        with gr.Column(scale=2):
+            gr.Markdown("### Generated Results")
+            
+            # Main output
+            with gr.Group(elem_classes=["image-container"]):
+                output_image = gr.Image(
+                    label="Generated Image",
+                    type="pil",
+                    height=400
+                )
+            
+            # Progress visualization
+            with gr.Group(elem_classes=["image-container"]):
+                progress_image = gr.Image(
+                    label="Generation Progress (showing progressive latents)",
+                    type="pil",
+                    height=100
+                )
+    
+    # Examples
+    gr.Markdown("### Examples")
+    examples = [
+        ["A mystical forest with glowing mushrooms and ethereal lighting", "blurry, low quality", 50, 7.5, -1, 512, 512],
+        ["A dramatic portrait with cinematic lighting", "cartoon, anime", 40, 8.0, 42, 768, 768],
+        ["An architectural interior with natural light streaming through windows", "dark, artificial lighting", 60, 6.5, -1, 512, 512],
+        ["A fantasy landscape with magical lighting effects", "realistic, photographic", 45, 9.0, 123, 1024, 512]
+    ]
+    
+    gr.Examples(
+        examples=examples,
+        inputs=[prompt, negative_prompt, num_steps, guidance_scale, seed, width, height],
+        outputs=[output_image, progress_image],
+        fn=generate_image,
+        cache_examples=True,
+        examples_per_page=4
+    )
+    
+    # Event handlers
+    generate_btn.click(
+        fn=generate_image,
+        inputs=[prompt, negative_prompt, num_steps, guidance_scale, seed, width, height],
+        outputs=[output_image, progress_image],
+        api_visibility="public"
+    )
+    
+    update_info_btn.click(
+        fn=update_info,
+        outputs=[model_info],
+        api_visibility="private"
+    )
+    
+    # Load initial info
+    demo.load(
+        fn=update_info,
+        outputs=[model_info],
+        api_visibility="private"
+    )
+
+# Launch the app
+demo.launch(
+    theme=gr.themes.Soft(
+        primary_hue="purple",
+        secondary_hue="blue",
+        neutral_hue="slate",
+        font=gr.themes.GoogleFont("Inter"),
+        text_size="lg",
+        spacing_size="lg",
+        radius_size="md"
+    ).set(
+        button_primary_background_fill="*primary_600",
+        button_primary_background_fill_hover="*primary_700",
+        block_title_text_weight="600",
+        block_border_width="1px",
+        block_border_color="*neutral_200"
+    ),
+    css=custom_css,
+    footer_links=[
+        {"label": "Built with anycoder", "url": "https://huggingface.co/spaces/akhaliq/anycoder"}
+    ]
+)

requirements.txt

@@ -0,0 +1,10 @@
+Pillow
+gradio>=6.0
+numpy
+torch
+torchvision
+torchaudio
+requests
+opencv-python
+matplotlib
+scipy