Deploy tiny text to image CPU Space

README.md

@@ -1,12 +1,31 @@
 ---
-title: Tiny Text To Image Cpu
-emoji: 🏃
-colorFrom: yellow
-colorTo: yellow
+title: Tiny Text To Image CPU
+colorFrom: blue
+colorTo: indigo
 sdk: gradio
-sdk_version: 6.9.0
+sdk_version: 5.23.0
+python_version: "3.10"
 app_file: app.py
 pinned: false
+models:
+  - segmind/tiny-sd
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Tiny Text To Image CPU
+
+This is a separate lightweight Hugging Face Space for text-to-image generation on free CPU hardware.
+
+Model:
+- `segmind/tiny-sd`
+
+Features:
+- Compact text-to-image model
+- CPU-oriented generation defaults
+- Style presets
+- Separate deployment from the TTS Spaces
+- No user token stored in the Space
+
+## Notes
+
+- This Space is designed for free CPU hardware, so generation is slower and image quality is lower than large GPU models.
+- The first request takes longer because the model downloads inside the Space.

app.py

@@ -0,0 +1,105 @@
+import gradio as gr
+
+from tiny_image_gen.catalog import STYLE_PRESETS, default_prompt, style_choices
+from tiny_image_gen.service import TinyImageService
+
+
+service = TinyImageService()
+
+
+def update_style(style_name: str):
+    return STYLE_PRESETS[style_name].hint
+
+
+def run_generation(prompt: str, style_name: str, negative_prompt: str, steps: int, guidance: float, seed: int):
+    return service.generate(
+        prompt=prompt,
+        style_name=style_name,
+        negative_prompt=negative_prompt,
+        steps=steps,
+        guidance=guidance,
+        seed=seed,
+    )
+
+
+with gr.Blocks(title="Tiny Text To Image CPU") as demo:
+    gr.Markdown(
+        """
+        # Tiny Text To Image CPU
+        Small text-to-image generation running on a free CPU Space.
+
+        - Model: `segmind/tiny-sd`
+        - Separate Space
+        - CPU-friendly defaults
+        - Single-image generation
+        """
+    )
+
+    with gr.Row():
+        with gr.Column():
+            prompt = gr.Textbox(
+                label="Prompt",
+                value=default_prompt(),
+                lines=6,
+            )
+            style = gr.Dropdown(
+                label="Style",
+                choices=style_choices(),
+                value="Cinematic",
+            )
+            style_hint = gr.Textbox(
+                label="Style Hint",
+                value=STYLE_PRESETS["Cinematic"].hint,
+                interactive=False,
+                lines=3,
+            )
+            negative_prompt = gr.Textbox(
+                label="Negative Prompt",
+                value="blurry, low quality, distorted, deformed, extra fingers, watermark, text",
+                lines=3,
+            )
+            steps = gr.Slider(
+                label="Steps",
+                minimum=4,
+                maximum=20,
+                value=10,
+                step=1,
+            )
+            guidance = gr.Slider(
+                label="Guidance Scale",
+                minimum=1.0,
+                maximum=10.0,
+                value=6.0,
+                step=0.5,
+            )
+            seed = gr.Number(
+                label="Seed",
+                value=42,
+                precision=0,
+            )
+            generate = gr.Button("Generate Image", variant="primary")
+
+        with gr.Column():
+            image = gr.Image(label="Image", type="pil")
+            status = gr.Textbox(label="Status", value=service.describe())
+            info = gr.Textbox(
+                label="Info",
+                value="This Space uses a compact diffusion model, so quality is lower than large GPU models but it fits free CPU hardware better.",
+                lines=6,
+            )
+
+    style.change(
+        fn=update_style,
+        inputs=style,
+        outputs=style_hint,
+    )
+
+    generate.click(
+        fn=run_generation,
+        inputs=[prompt, style, negative_prompt, steps, guidance, seed],
+        outputs=[image, status, info],
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,7 @@
+accelerate>=0.33.0
+diffusers>=0.31.0
+gradio==5.23.0
+Pillow>=10.0.0
+safetensors>=0.4.4
+torch>=2.3.0
+transformers>=4.46.1

tiny_image_gen/__init__.py

@@ -0,0 +1,3 @@
+from .service import TinyImageService
+
+__all__ = ["TinyImageService"]

tiny_image_gen/catalog.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class StylePreset:
+    suffix: str
+    hint: str
+
+
+STYLE_PRESETS = {
+    "Cinematic": StylePreset(
+        suffix="cinematic lighting, highly detailed, dramatic composition, rich colors",
+        hint="Adds film-like lighting and richer detail.",
+    ),
+    "Anime": StylePreset(
+        suffix="anime style, clean line art, vibrant colors, expressive composition",
+        hint="Pushes the output toward anime illustration.",
+    ),
+    "Fantasy": StylePreset(
+        suffix="fantasy art, magical atmosphere, detailed environment, epic scene",
+        hint="Adds a fantasy painting look.",
+    ),
+    "Pixel Art": StylePreset(
+        suffix="pixel art, retro game sprite style, sharp edges, limited color palette",
+        hint="Pushes toward retro pixel-art aesthetics.",
+    ),
+    "Photographic": StylePreset(
+        suffix="photo realistic, natural light, realistic detail, professional photography",
+        hint="Pushes toward a photographic look.",
+    ),
+}
+
+
+def style_choices() -> list[str]:
+    return list(STYLE_PRESETS.keys())
+
+
+def default_prompt() -> str:
+    return "A futuristic city street at sunset with neon reflections after rain"

tiny_image_gen/service.py

@@ -0,0 +1,93 @@
+import random
+from threading import Lock
+
+import gradio as gr
+import torch
+from diffusers import StableDiffusionPipeline
+
+from .catalog import STYLE_PRESETS
+
+
+MODEL_ID = "segmind/tiny-sd"
+DEVICE = "cpu"
+IMAGE_SIZE = 384
+BLOCKED_TERMS = {
+    "child sexual",
+    "sexual minor",
+    "rape",
+    "gore torture",
+}
+
+
+class TinyImageService:
+    def __init__(self):
+        self._lock = Lock()
+        self._pipe = None
+        torch.set_num_threads(4)
+
+    def describe(self) -> str:
+        return "Tiny image generator ready. The model loads on first use."
+
+    def _ensure_pipe(self):
+        with self._lock:
+            if self._pipe is not None:
+                return
+
+            pipe = StableDiffusionPipeline.from_pretrained(
+                MODEL_ID,
+                torch_dtype=torch.float32,
+                safety_checker=None,
+                requires_safety_checker=False,
+                low_cpu_mem_usage=True,
+                use_safetensors=True,
+            )
+            pipe = pipe.to(DEVICE)
+            pipe.enable_attention_slicing()
+            pipe.enable_vae_slicing()
+            pipe.set_progress_bar_config(disable=True)
+            self._pipe = pipe
+
+    def generate(
+        self,
+        prompt: str,
+        style_name: str,
+        negative_prompt: str,
+        steps: int,
+        guidance: float,
+        seed: int,
+    ):
+        clean_prompt = " ".join(prompt.split())
+        clean_negative = " ".join(negative_prompt.split())
+        if not clean_prompt:
+            raise gr.Error("Prompt is required.")
+
+        lowered = clean_prompt.lower()
+        if any(term in lowered for term in BLOCKED_TERMS):
+            raise gr.Error("Prompt is not allowed.")
+
+        style = STYLE_PRESETS[style_name]
+        final_prompt = f"{clean_prompt}, {style.suffix}"
+        self._ensure_pipe()
+
+        seed_value = int(seed) if seed is not None else random.randint(1, 2**31 - 1)
+        generator = torch.Generator(device=DEVICE).manual_seed(seed_value)
+
+        with self._lock:
+            result = self._pipe(
+                prompt=final_prompt,
+                negative_prompt=clean_negative or None,
+                num_inference_steps=int(steps),
+                guidance_scale=float(guidance),
+                width=IMAGE_SIZE,
+                height=IMAGE_SIZE,
+                generator=generator,
+            )
+
+        image = result.images[0]
+        status = f"Generated image with {MODEL_ID} on CPU. Seed={seed_value}."
+        info = (
+            f"Final prompt:\n{final_prompt}\n\n"
+            f"Negative prompt:\n{clean_negative or 'None'}\n\n"
+            f"Steps: {int(steps)} | Guidance: {float(guidance):.1f} | Size: {IMAGE_SIZE}x{IMAGE_SIZE}"
+        )
+        return image, status, info