Switch to n-Arno AIO Q4_K GGUF (single 1.79 GB file, restores GGUF speed)

README.md

@@ -15,11 +15,11 @@ tags:
 
 # Anima Preview3 Image Generation (CPU)
 
-Generate anime images with [Anima Preview3](https://huggingface.co/circlestone-labs/Anima) + new Turbo LoRA on free CPU hardware.
+Generate anime images with [Anima Preview3](https://huggingface.co/circlestone-labs/Anima) + Turbo LoRA, packaged as a single Q4_K GGUF for sd.cpp.
 
 - Engine: stable-diffusion.cpp (compiled from source)
-- Diffusion model: anima-preview3-base.safetensors (4.2 GB, fp16)
-- Text encoder: qwen_3_06b_base.safetensors
-- VAE: qwen_image_vae.safetensors
-- Turbo LoRA: [dummy9996/Anima-Turbo-LoRA](https://huggingface.co/dummy9996/Anima-Turbo-LoRA) (HF mirror of civitai.com/models/2560840), 8-12 steps at CFG 1
-- Hardware: CPU Basic — ~50 min per 512×512 generation
+- Model: [n-Arno/Anima-P3-Turbo-AIO-Q4_K](https://huggingface.co/n-Arno/Anima-P3-Turbo-AIO-Q4_K) — 1.79 GB
+  - Concatenates VAE + LLM (Qwen3-0.6B text encoder) + DiT + Turbo LoRA (from civitai.com/models/2560840)
+  - Quantized to Q4_K via `sd-cli -M convert`
+- Settings: CFG 1, sampler `er_sde`, scheduler `smoothstep`, 16 steps, `--cache-mode spectrum`, `--offload-to-cpu`
+- Hardware: CPU Basic — ~30 min per 512×512 generation

app.py

@@ -1,48 +1,35 @@
-"""Anima Preview3 Image Generation (CPU) via sd-cli binary"""
+"""Anima Preview3 + Turbo (AIO GGUF) Image Generation (CPU) via sd-cli binary"""
 
 import os, time, subprocess, tempfile, shutil, threading
-from pathlib import Path
 from PIL import Image
 from huggingface_hub import hf_hub_download
 import gradio as gr
 
 # ---------------------------------------------------------------------------
-# Download models
+# Download single AIO GGUF model file (VAE + LLM + DiT + Turbo LoRA, all merged)
 # ---------------------------------------------------------------------------
 MODELS_DIR = "/tmp/anima_models"
-LORA_DIR = "/tmp/loras"
 os.makedirs(MODELS_DIR, exist_ok=True)
-os.makedirs(LORA_DIR, exist_ok=True)
 
-def ensure_model(repo_id, filename, subdir=""):
+
+def ensure_model(repo_id, filename):
     path = os.path.join(MODELS_DIR, filename)
     if os.path.exists(path):
         return path
-    print(f"[init] Downloading {repo_id}/{subdir}/{filename}...")
-    src = hf_hub_download(
-        repo_id=repo_id,
-        filename=f"{subdir}/{filename}" if subdir else filename,
-    )
+    print(f"[init] Downloading {repo_id}/{filename}...")
+    src = hf_hub_download(repo_id=repo_id, filename=filename)
     shutil.copy2(src, path)
     return path
 
-print("[init] Ensuring model files...")
+
+print("[init] Ensuring AIO GGUF model file...")
 t0 = time.time()
-diffusion_path = ensure_model(
-    "circlestone-labs/Anima",
-    "anima-preview3-base.safetensors",
-    "split_files/diffusion_models",
+# n-Arno's "All In One" build: VAE + LLM (text encoder) + DiT + Turbo LoRA
+# concatenated and quantized to Q4_K. 1.79 GB. Made specifically for sd.cpp.
+aio_path = ensure_model(
+    "n-Arno/Anima-P3-Turbo-AIO-Q4_K", "Anima-P3-Turbo-AIO-Q4_K.gguf"
 )
-llm_path = ensure_model("circlestone-labs/Anima", "qwen_3_06b_base.safetensors", "split_files/text_encoders")
-vae_path = ensure_model("circlestone-labs/Anima", "qwen_image_vae.safetensors", "split_files/vae")
-
-# Turbo LoRA trained on Preview3 (HF mirror of civitai.com/models/2560840)
-lora_src = hf_hub_download("dummy9996/Anima-Turbo-LoRA", "anima-turbo-lora-v0.1.safetensors")
-lora_path = os.path.join(LORA_DIR, "anima_preview3_turbo.safetensors")
-if not os.path.exists(lora_path):
-    shutil.copy2(lora_src, lora_path)
-
-print(f"[init] Models ready in {time.time()-t0:.1f}s")
+print(f"[init] Model ready in {time.time()-t0:.1f}s")
 
 # ---------------------------------------------------------------------------
 # Active process tracking (kill on user disconnect)
@@ -53,14 +40,14 @@ _proc_lock = threading.Lock()
 # ---------------------------------------------------------------------------
 # Inference via sd-cli binary
 # ---------------------------------------------------------------------------
-RESOLUTIONS = ["512x512", "768x512", "512x768"]
+RESOLUTIONS = ["512x512", "768x512", "512x768", "832x1216"]
 CFG = 1.0
 TIMEOUT = 10800
-# Coefficient calibrated for Preview3 fp16 safetensors on CPU Basic
-# (current GGUF was ~15 min/512x512/8steps; fp16 is ~3-4x slower)
-EST_MIN_PER_512_8STEPS = 50
+# Calibration: Q4_K AIO GGUF at 16 steps + 512x512 ≈ 30 min on CPU Basic.
+EST_MIN_PER_512_16STEPS = 30
 
-def generate(prompt, negative_prompt, resolution, steps, lora_strength, seed):
+
+def generate(prompt, negative_prompt, resolution, steps, seed):
     global _active_proc
 
     if not prompt or not prompt.strip():
@@ -68,13 +55,12 @@ def generate(prompt, negative_prompt, resolution, steps, lora_strength, seed):
 
     prompt = prompt.strip()[:500]
     steps = int(steps)
-    lora_strength = float(lora_strength)
 
     w, h = (int(x) for x in resolution.split("x"))
     pixels = w * h
-    est_min = int(pixels / 512 / 512 * steps / 8 * EST_MIN_PER_512_8STEPS)
+    est_min = int(pixels / 512 / 512 * steps / 16 * EST_MIN_PER_512_16STEPS)
 
-    if est_min > 120:
+    if est_min > 180:
         raise gr.Error(f"Estimated ~{est_min} min — too slow for CPU. Use 512x512 or fewer steps.")
 
     seed = int(seed or -1) if seed is not None else -1
@@ -84,26 +70,26 @@ def generate(prompt, negative_prompt, resolution, steps, lora_strength, seed):
 
     cmd = [
         "sd-cli",
-        "--diffusion-model", diffusion_path,
-        "--llm", llm_path,
-        "--vae", vae_path,
-        "--lora-model-dir", LORA_DIR,
-        "-p", f"<lora:anima_preview3_turbo:{lora_strength}> {prompt}",
+        "-m", aio_path,
+        "-p", prompt,
         "-n", negative_prompt or "",
         "-W", str(w),
         "-H", str(h),
         "--steps", str(steps),
         "--cfg-scale", str(CFG),
-        "--sampling-method", "dpm++2m",
-        "-o", output_path,
-        "--diffusion-fa",
+        "--sampling-method", "er_sde",
+        "--scheduler", "smoothstep",
+        "--cache-mode", "spectrum",
         "--vae-tiling",
+        "--fa",
+        "--offload-to-cpu",
+        "-o", output_path,
         "-v",
     ]
     if seed >= 0:
         cmd += ["-s", str(seed)]
 
-    print(f"[gen] {w}x{h} steps={steps} lora={lora_strength} seed={seed} est~{est_min}min prompt={prompt[:80]}")
+    print(f"[gen] {w}x{h} steps={steps} seed={seed} est~{est_min}min prompt={prompt[:80]}")
     t0 = time.time()
 
     try:
@@ -133,7 +119,7 @@ def generate(prompt, negative_prompt, resolution, steps, lora_strength, seed):
             raise gr.Error("No output image generated")
 
         img = Image.open(output_path)
-        status = f"Generated in {elapsed:.1f}s ({w}x{h}, {steps} steps, lora={lora_strength})"
+        status = f"Generated in {elapsed:.1f}s ({w}x{h}, {steps} steps)"
         print(f"[gen] {status}")
         return img, status
 
@@ -150,15 +136,16 @@ def generate(prompt, negative_prompt, resolution, steps, lora_strength, seed):
             _active_proc = None
         raise gr.Error(f"Error: {e}")
 
+
 # ---------------------------------------------------------------------------
 # Gradio UI
 # ---------------------------------------------------------------------------
 with gr.Blocks(title="Anima Preview3 (CPU)") as demo:
     gr.Markdown(
-        "**[Anima Preview3](https://huggingface.co/circlestone-labs/Anima)** safetensors "
-        "+ [Turbo LoRA v0.1](https://huggingface.co/dummy9996/Anima-Turbo-LoRA) (CFG 1, 8-12 steps) "
+        "**[Anima Preview3 + Turbo AIO Q4_K](https://huggingface.co/n-Arno/Anima-P3-Turbo-AIO-Q4_K)** GGUF "
+        "(VAE + LLM + DiT + Turbo LoRA merged into 1.79 GB) "
         "via [sd.cpp](https://github.com/leejet/stable-diffusion.cpp) | "
-        "**~50 min** at 512x512 on free CPU. Lower LoRA strength = more variety, slightly less stability."
+        "**~30 min** at 512x512 / 16 steps on free CPU"
     )
     with gr.Row():
         with gr.Column():
@@ -168,8 +155,7 @@ with gr.Blocks(title="Anima Preview3 (CPU)") as demo:
                 value="worst quality, low quality, score_1, score_2, score_3, artist name")
             with gr.Row():
                 res_input = gr.Dropdown(choices=RESOLUTIONS, value="512x512", label="Resolution")
-                steps_input = gr.Slider(8, 12, value=8, step=1, label="Steps")
-                strength_input = gr.Slider(0.5, 1.0, value=1.0, step=0.05, label="LoRA strength")
+                steps_input = gr.Slider(8, 20, value=16, step=1, label="Steps")
                 seed_input = gr.Number(value=-1, label="Seed (-1=random)", precision=0)
             gen_btn = gr.Button("Generate", variant="primary", size="lg")
         with gr.Column():
@@ -177,7 +163,7 @@ with gr.Blocks(title="Anima Preview3 (CPU)") as demo:
             status_box = gr.Textbox(label="Status", interactive=False)
 
     gen_btn.click(fn=generate,
-        inputs=[prompt_input, neg_input, res_input, steps_input, strength_input, seed_input],
+        inputs=[prompt_input, neg_input, res_input, steps_input, seed_input],
         outputs=[output_img, status_box],
         concurrency_limit=1)