Upload folder using huggingface_hub

app.py

@@ -0,0 +1,128 @@
+import gradio as gr
+import torch
+from model_handler import ModelHandler
+from utils import get_random_seed
+
+# Initialize the model handler
+# We initialize it here to load the model when the app starts
+model_handler = ModelHandler()
+
+def generate(
+    prompt, 
+    negative_prompt, 
+    width, 
+    height, 
+    steps, 
+    guidance_scale, 
+    seed, 
+    progress=gr.Progress()
+):
+    """
+    Wrapper function to call the model inference.
+    """
+    if seed < 0:
+        seed = get_random_seed()
+    
+    try:
+        image = model_handler.infer(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            width=width,
+            height=height,
+            num_inference_steps=steps,
+            guidance_scale=guidance_scale,
+            seed=seed,
+            progress_callback=progress
+        )
+        return image, seed
+    except Exception as e:
+        raise gr.Error(f"Generation failed: {str(e)}")
+
+# CSS for custom styling
+css = """
+.container { max-width: 900px; margin: auto; }
+.header { text-align: center; margin-bottom: 20px; }
+.header h1 { font-size: 2.5rem; font-weight: bold; color: #333; }
+.header p { font-size: 1.1rem; color: #666; }
+.footer { text-align: center; margin-top: 20px; font-size: 0.9rem; }
+"""
+
+# Create the Gradio Interface
+with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
+    
+    with gr.Column(elem_classes="container"):
+        # Header
+        with gr.Column(elem_classes="header"):
+            gr.Markdown(
+                """
+                # Kandinsky 5.0 Lite T2I (SFT)
+                ### Text-to-Image Generation
+                """
+            )
+            gr.Markdown("[Built with anycoder](https://huggingface.co/spaces/akhaliq/anycoder)")
+        
+        # Status info for hardware
+        device_info = "Running on **GPU** 🚀" if torch.cuda.is_available() else "Running on **CPU** ⚠️ (Inference will be slow)"
+        gr.Markdown(device_info)
+
+        with gr.Row():
+            # Left Column: Inputs
+            with gr.Column(scale=1):
+                prompt = gr.Textbox(
+                    label="Prompt",
+                    placeholder="Describe the image you want to generate...",
+                    lines=3,
+                    autofocus=True
+                )
+                
+                negative_prompt = gr.Textbox(
+                    label="Negative Prompt",
+                    placeholder="Low quality, bad anatomy, blurry...",
+                    lines=2,
+                    value="low quality, bad anatomy, worst quality, deformed, disfigured"
+                )
+                
+                with gr.Accordion("Advanced Settings", open=False):
+                    with gr.Row():
+                        width = gr.Slider(label="Width", minimum=256, maximum=1024, step=64, value=1024)
+                        height = gr.Slider(label="Height", minimum=256, maximum=1024, step=64, value=1024)
+                    
+                    steps = gr.Slider(label="Inference Steps", minimum=10, maximum=100, step=1, value=25)
+                    guidance_scale = gr.Slider(label="Guidance Scale", minimum=1.0, maximum=20.0, step=0.5, value=7.5)
+                    
+                    with gr.Row():
+                        seed = gr.Number(label="Seed", value=-1, precision=0, info="Set to -1 for random")
+                        random_btn = gr.Button("🎲 Randomize", size="sm", variant="secondary")
+
+                run_btn = gr.Button("Generate Image", variant="primary", size="lg")
+
+            # Right Column: Output
+            with gr.Column(scale=1):
+                result_image = gr.Image(label="Generated Image", type="pil", interactive=False)
+                used_seed = gr.Number(label="Seed Used", interactive=False)
+
+    # Event Handlers
+    run_btn.click(
+        fn=generate,
+        inputs=[prompt, negative_prompt, width, height, steps, guidance_scale, seed],
+        outputs=[result_image, used_seed]
+    )
+    
+    # Helper to randomize seed input visually
+    random_btn.click(lambda: -1, outputs=seed)
+    
+    # Examples
+    gr.Examples(
+        examples=[
+            ["A futuristic cityscape with neon lights and flying cars, cyberpunk style, high detail", "low quality, blurry", 1024, 1024, 25, 7.5],
+            ["A cute red panda drinking coffee in a cozy cafe, digital art", "deformed, ugly", 1024, 1024, 25, 7.0],
+            ["Portrait of a warrior princess, intricate armor, dramatic lighting, photorealistic", "cartoon, sketch, monochrome", 1024, 1024, 30, 8.0]
+        ],
+        inputs=[prompt, negative_prompt, width, height, steps, guidance_scale],
+        fn=generate,
+        outputs=[result_image, used_seed],
+        cache_examples=False 
+    )
+
+if __name__ == "__main__":
+    demo.launch()

config.py

@@ -0,0 +1,5 @@
+# Configuration settings (Optional, but good practice)
+MODEL_ID = "kandinskylab/Kandinsky-5.0-T2I-Lite-sft-Diffusers"
+MAX_IMAGE_SIZE = 1024
+DEFAULT_STEPS = 50
+DEFAULT_GUIDANCE = 3.5

model_handler.py

@@ -0,0 +1,68 @@
+import torch
+from diffusers import AutoPipelineForTextToImage
+import os
+
+class ModelHandler:
+    def __init__(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model_id = "kandinskylab/Kandinsky-5.0-T2I-Lite-sft-Diffusers"
+        self.pipeline = None
+        self.load_model()
+
+    def load_model(self):
+        """
+        Loads the model pipeline. Uses float16 for GPU to save memory.
+        """
+        try:
+            print(f"Loading model: {self.model_id} on {self.device}...")
+            
+            dtype = torch.float16 if self.device == "cuda" else torch.float32
+            
+            # AutoPipeline handles the architecture detection automatically
+            self.pipeline = AutoPipelineForTextToImage.from_pretrained(
+                self.model_id,
+                torch_dtype=dtype,
+                use_safetensors=True
+            )
+            
+            if self.device == "cuda":
+                self.pipeline.to("cuda")
+                # Optional: Enable CPU offload if VRAM is limited (e.g. < 8GB)
+                # self.pipeline.enable_model_cpu_offload() 
+            
+            print("Model loaded successfully.")
+            
+        except Exception as e:
+            print(f"Error loading model: {e}")
+            # Fallback or re-raise depending on deployment needs
+            raise e
+
+    def infer(self, prompt, negative_prompt, width, height, num_inference_steps, guidance_scale, seed, progress_callback=None):
+        """
+        Runs inference on the loaded pipeline.
+        """
+        if self.pipeline is None:
+            self.load_model()
+
+        generator = torch.Generator(device=self.device).manual_seed(int(seed))
+        
+        # Progress bar handling
+        def callback_dynamic(step, timestep, latents):
+            if progress_callback:
+                progress_callback((step, num_inference_steps))
+
+        # Depending on the specific diffusers version or pipeline type, 
+        # callback usage might vary slightly, but this is standard for recent versions.
+        image = self.pipeline(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            width=width,
+            height=height,
+            num_inference_steps=num_inference_steps,
+            guidance_scale=guidance_scale,
+            generator=generator,
+            # callback=callback_dynamic, # Optional: enable for granular progress updates
+            # callback_steps=1
+        ).images[0]
+        
+        return image

requirements.txt

@@ -0,0 +1,21 @@
+gradio
+torch
+torchvision
+torchaudio
+numpy
+Pillow
+requests
+accelerate
+git+https://github.com/huggingface/transformers
+git+https://github.com/huggingface/diffusers
+sentencepiece
+tokenizers
+datasets
+scipy
+joblib
+opencv-python
+matplotlib
+pandas
+openpyxl
+PyPDF2
+python-docx

utils.py

@@ -0,0 +1,8 @@
+import random
+import time
+
+def get_random_seed():
+    """
+    Generates a random seed based on system time.
+    """
+    return random.randint(0, 2**32 - 1)