Add 10Eros Space (TenStrip/LTX2.3-10Eros layer-scaled merge)

10Eros/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

10Eros/README.md

@@ -0,0 +1,24 @@
+---
+title: LTX2.3-10Eros
+emoji: 🔥
+colorFrom: orange
+colorTo: red
+sdk: gradio
+sdk_version: "6.14.0"
+python_version: "3.12"
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# 10Eros — Image to Video
+
+Upload an image and prompt, and 10Eros will animate it into a short video clip.
+
+**Model**
+- **10Eros** — LTX-2.3 layer-scaled merge built on Sulphur-2-base
+
+**Tips**
+- Landscape images work best at 832×480; portrait at 480×832
+- Keep prompts focused on motion (e.g. "hair blowing in the wind, slow pan")
+- 8 steps is fast; raise to 20–30 for finer detail

10Eros/app.py

@@ -0,0 +1,203 @@
+"""
+10Eros — Image to Video (HF Spaces).
+Clones Wan2GP and downloads models on first run.
+Generation is handled by generate.py called as a subprocess inside @spaces.GPU.
+"""
+
+import os
+import sys
+import subprocess
+import shutil
+import tempfile
+import threading
+import json
+from pathlib import Path
+
+import gradio as gr
+import spaces
+
+_HF_TOKEN    = os.environ.get("HF_TOKEN")
+_PERSISTENT  = Path("/data") if Path("/data").exists() else Path(tempfile.gettempdir())
+WAN2GP_ROOT  = _PERSISTENT / "Wan2GP"
+CKPTS_DIR    = WAN2GP_ROOT / "ckpts"
+LORAS_DIR    = WAN2GP_ROOT / "loras" / "ltx2"
+FINETUNES_DIR = WAN2GP_ROOT / "finetunes"
+GENERATE_PY  = Path(__file__).parent / "generate.py"
+
+MODEL_ASSETS = [
+    ("TenStrip/LTX2.3-10Eros", "10Eros_v1_bf16.safetensors", CKPTS_DIR),
+]
+LTX_ASSETS = [
+    ("SulphurAI/Sulphur-2-base", "distill_loras/ltx-2.3-22b-distilled-lora-1.1_fro90_ceil72_condsafe.safetensors", LORAS_DIR),
+    ("DeepBeepMeep/LTX-2", "ltx-2.3-22b_vae.safetensors",                    CKPTS_DIR),
+    ("DeepBeepMeep/LTX-2", "ltx-2.3-22b_text_embedding_projection.safetensors", CKPTS_DIR),
+    ("DeepBeepMeep/LTX-2", "ltx-2.3-22b_embeddings_connector.safetensors",   CKPTS_DIR),
+]
+
+MODEL_FINETUNE = {
+    "model": {
+        "name": "10Eros",
+        "visible": True,
+        "architecture": "ltx2_22B",
+        "parent_model_type": "ltx2_22B",
+        "description": "LTX-2.3 layer-scaled merge i2v. Built on Sulphur-2-base.",
+        "URLs": [str(CKPTS_DIR / "10Eros_v1_bf16.safetensors")],
+        "preload_URLs": [],
+    },
+    "num_inference_steps": 8,
+    "video_length": 81,
+    "resolution": "832x480",
+    "guidance_scale": 3.5,
+    "alt_guidance_scale": 3.5,
+}
+
+_setup_lock = threading.Lock()
+_setup_done = False
+
+
+def _download(repo_id, filename, dest_dir):
+    from huggingface_hub import hf_hub_download
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    dest = dest_dir / Path(filename).name  # flat — strip any subfolder
+    if dest.exists():
+        print(f"[download] cached: {dest.name}")
+        return
+    print(f"[download] {repo_id}/{filename}")
+    hf_hub_download(repo_id=repo_id, filename=filename,
+                    local_dir=str(dest_dir), token=_HF_TOKEN)
+    # hf_hub_download preserves subfolder structure; flatten to dest_dir root
+    downloaded = dest_dir / filename
+    if downloaded.exists() and not dest.exists():
+        shutil.move(str(downloaded), str(dest))
+
+
+def setup():
+    global _setup_done
+    with _setup_lock:
+        if _setup_done:
+            return
+        _setup_done = True
+
+    if not (WAN2GP_ROOT / "shared" / "api.py").exists():
+        WAN2GP_ROOT.mkdir(parents=True, exist_ok=True)
+        print("[setup] Cloning Wan2GP...")
+        subprocess.run(
+            ["git", "clone", "--depth=1",
+             "https://github.com/deepbeepmeep/Wan2GP.git", str(WAN2GP_ROOT)],
+            check=True,
+        )
+
+    for repo, fname, dest in MODEL_ASSETS + LTX_ASSETS:
+        _download(repo, fname, dest)
+
+    # Gemma text encoder — must stay in its subfolder (Wan2GP looks there by name)
+    _gemma_folder = "gemma-3-12b-it-qat-q4_0-unquantized"
+    _gemma_file = f"{_gemma_folder}_quanto_bf16_int8.safetensors"
+    gemma_dest = CKPTS_DIR / _gemma_folder / _gemma_file
+    if not gemma_dest.exists():
+        from huggingface_hub import hf_hub_download
+        print("[download] Gemma text encoder...")
+        hf_hub_download(
+            repo_id="DeepBeepMeep/LTX-2",
+            filename=f"{_gemma_folder}/{_gemma_file}",
+            local_dir=str(CKPTS_DIR),
+            token=_HF_TOKEN,
+        )
+    else:
+        print("[download] cached: Gemma text encoder")
+
+    FINETUNES_DIR.mkdir(parents=True, exist_ok=True)
+    (FINETUNES_DIR / "ten_eros.json").write_text(json.dumps(MODEL_FINETUNE, indent=2))
+    print("[setup] Done.")
+
+
+setup()
+
+RESOLUTIONS = ["832x480", "480x832", "640x640", "1024x576", "576x1024"]
+
+
+@spaces.GPU(duration=120)
+def generate_video(image, prompt, resolution, steps, guidance_scale, frames, seed):
+    if image is None:
+        raise gr.Error("Please upload an image.")
+    if not prompt.strip():
+        raise gr.Error("Please enter a prompt.")
+
+    out_file = Path(tempfile.mkdtemp()) / "output.mp4"
+    env = {**os.environ, "WAN2GP_ROOT": str(WAN2GP_ROOT)}
+
+    cmd = [
+        sys.executable, str(GENERATE_PY),
+        "--image",  image,
+        "--prompt", prompt,
+        "--output", str(out_file),
+        "--model",  "10eros",
+        "--seed",   str(int(seed)),
+        "--resolution", resolution,
+        "--steps",  str(int(steps)),
+        "--guidance_scale", str(float(guidance_scale)),
+        "--frames", str(int(frames)),
+    ]
+
+    log_lines = []
+    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                            text=True, bufsize=0, env=env)
+
+    buf = ""
+    while True:
+        chunk = proc.stdout.read(256)
+        if not chunk:
+            break
+        buf += chunk
+        # Split on \r or \n — tqdm uses \r to overwrite progress lines
+        parts = buf.replace("\r", "\n").split("\n")
+        buf = parts[-1]
+        for part in parts[:-1]:
+            stripped = part.strip()
+            if not stripped:
+                continue
+            # Overwrite last line if it looks like a progress bar update
+            if log_lines and ("%" in stripped or "it/s" in stripped or "step" in stripped.lower()):
+                log_lines[-1] = stripped
+            else:
+                log_lines.append(stripped)
+            print(stripped)
+            yield None, "\n".join(log_lines[-30:])
+
+    proc.wait()
+    log = "\n".join(log_lines)
+
+    if proc.returncode != 0 or not out_file.exists():
+        yield None, log + "\n\n[ERROR] Generation failed."
+        return
+
+    final = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
+    shutil.copy2(out_file, final.name)
+    yield final.name, log + "\n\n[DONE]"
+
+
+with gr.Blocks(title="10Eros — Image to Video") as demo:
+    gr.Markdown("# 10Eros — Image to Video\nPowered by Wan2GP · LTX-2.3 layer-scaled merge")
+    with gr.Row():
+        with gr.Column(scale=1):
+            image_in  = gr.Image(type="filepath", label="Input Image")
+            prompt_in = gr.Textbox(label="Prompt", placeholder="Describe the motion…", lines=3)
+            with gr.Accordion("Advanced", open=False):
+                resolution_dd = gr.Dropdown(RESOLUTIONS, value="832x480", label="Resolution")
+                steps_sl      = gr.Slider(1, 50, value=8,   step=1,   label="Steps")
+                guidance_sl   = gr.Slider(1.0, 10.0, value=5.0, step=0.5, label="Guidance Scale")
+                frames_sl     = gr.Slider(17, 257, value=81, step=8,  label="Frames")
+                seed_num      = gr.Number(value=-1, label="Seed (-1 = random)", precision=0)
+            run_btn = gr.Button("Generate", variant="primary")
+        with gr.Column(scale=1):
+            video_out = gr.Video(label="Output Video")
+            log_out   = gr.Textbox(label="Log", lines=10, interactive=False)
+
+    run_btn.click(
+        fn=generate_video,
+        inputs=[image_in, prompt_in, resolution_dd, steps_sl, guidance_sl, frames_sl, seed_num],
+        outputs=[video_out, log_out],
+    )
+
+if __name__ == "__main__":
+    demo.launch(theme=gr.themes.Soft())

10Eros/generate.py

@@ -0,0 +1,139 @@
+"""
+HF Spaces version of generate.py — same logic, paths adapted for /tmp/Wan2GP.
+Called as a subprocess from app.py inside @spaces.GPU.
+"""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+WAN2GP_ROOT = Path(os.environ.get("WAN2GP_ROOT", "/tmp/Wan2GP"))
+
+MODEL_SHORTHANDS = {
+    "10eros": "ten_eros",
+}
+
+DEFAULTS = {
+    "ten_eros": {
+        "num_inference_steps": 8,
+        "guidance_scale":      5.0,
+        "resolution":          "832x480",
+        "video_length":        81,
+    },
+}
+
+
+def p(*args, **kwargs):
+    print(*args, **kwargs, flush=True)
+
+
+def parse_args():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--image",          required=True)
+    ap.add_argument("--prompt",         required=True)
+    ap.add_argument("--output",         required=True)
+    ap.add_argument("--model",          default="10eros")
+    ap.add_argument("--steps",          type=int,   default=None)
+    ap.add_argument("--guidance_scale", type=float, default=None)
+    ap.add_argument("--frames",         type=int,   default=None)
+    ap.add_argument("--resolution",     default=None)
+    ap.add_argument("--seed",           type=int,   default=-1)
+    return ap.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    model_type = MODEL_SHORTHANDS.get(args.model, args.model)
+    defaults   = DEFAULTS.get(model_type, DEFAULTS["ten_eros"])
+
+    image_path = str(Path(args.image.strip()).resolve())
+    if not Path(image_path).exists():
+        print(f"Fatal: image not found: {image_path}", flush=True)
+        sys.exit(1)
+
+    resolution = args.resolution or defaults["resolution"]
+    if not args.resolution:
+        try:
+            from PIL import Image as _PIL
+            img = _PIL.open(image_path)
+            iw, ih = img.size
+            if ih > iw:
+                tw = 480
+                th = round(ih / iw * tw / 32) * 32
+            else:
+                th = 480
+                tw = round(iw / ih * th / 32) * 32
+            resolution = f"{tw}x{th}"
+            p(f"Auto-detected resolution: {resolution} (from {iw}x{ih} input)")
+        except Exception:
+            pass
+
+    task = {
+        "model_type":           model_type,
+        "base_model_type":      model_type,
+        "prompt":               args.prompt,
+        "image_start":          image_path,
+        "num_inference_steps":  args.steps         or defaults["num_inference_steps"],
+        "guidance_scale":       args.guidance_scale or defaults["guidance_scale"],
+        "resolution":           resolution,
+        "video_length":         args.frames        or defaults["video_length"],
+        "seed":                 args.seed,
+        "image_prompt_type":    "S",
+        "input_video_strength": 1.0,
+        "activated_loras": [
+            "ltx-2.3-22b-distilled-lora-1.1_fro90_ceil72_condsafe.safetensors",
+        ],
+        "loras_multipliers": ["0.5"],
+    }
+
+    p(f"Model:      {model_type}")
+    p(f"Image:      {image_path}")
+    p(f"Steps:      {task['num_inference_steps']}  Guidance: {task['guidance_scale']}")
+    p(f"Resolution: {task['resolution']}  Frames: {task['video_length']}")
+    p(f"Prompt:     {args.prompt[:80]}")
+
+    sys.path.insert(0, str(WAN2GP_ROOT))
+    os.chdir(WAN2GP_ROOT)
+
+    from shared.api import WanGPSession
+
+    output_dir = Path(args.output).parent
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    p("Starting session...")
+    session = WanGPSession(root=WAN2GP_ROOT, output_dir=output_dir, console_output=True)
+
+    p("Running generation...")
+    result = session.run_task(task)
+
+    output_file = None
+
+    if result.artifacts:
+        src = result.artifacts[0].path
+        if src and Path(src).exists():
+            output_file = src
+
+    # Fallback: scan the output dir for any video file Wan2GP may have written
+    if output_file is None:
+        candidates = sorted(output_dir.glob("**/*.mp4"), key=lambda f: f.stat().st_mtime, reverse=True)
+        if candidates:
+            output_file = str(candidates[0])
+            p(f"Found output via dir scan: {output_file}")
+
+    if output_file:
+        import shutil
+        shutil.copy2(output_file, args.output)
+        p(f"Done: {args.output}")
+    else:
+        p(f"No output found in {output_dir}")
+        if result.errors:
+            p(f"Errors: {result.errors}")
+        sys.exit(1)
+
+    session.close()
+
+
+if __name__ == "__main__":
+    main()

10Eros/requirements.txt

@@ -0,0 +1,74 @@
+# HF Spaces runtime
+gradio>=6.0.0
+spaces
+huggingface_hub>=0.24.0
+
+# Wan2GP deps (from requirements.txt — all packages that install on Linux)
+mmgp==3.7.6
+diffusers==0.36.0
+transformers==4.54.0
+tokenizers>=0.20.3
+accelerate>=1.1.1
+tqdm
+imageio
+imageio-ffmpeg
+einops
+sentencepiece
+open_clip_torch>=2.29.0
+numpy==2.1.2
+num2words==0.5.14
+moviepy==1.0.3
+av
+ffmpeg-python
+pygame>=2.1.0
+sounddevice>=0.4.0
+soundfile
+mutagen
+pyloudnorm
+librosa==0.11.0
+speechbrain==1.0.3
+openai-whisper==20250625
+audio-separator==0.36.1
+pyannote.audio==3.3.2
+loguru
+dashscope
+s3tokenizer
+conformer==0.3.2
+spacy_pkuseg
+spacy
+opencv-python-headless>=4.12.0.88
+pycocotools
+segment-anything
+rembg==2.0.65
+onnxruntime>=1.20.0
+decord
+timm
+iopath>=0.1.10
+insightface==0.7.3
+facexlib==0.3.0
+vector_quantize_pytorch==1.27.19
+omegaconf
+hydra-core
+easydict
+torchdiffeq>=0.2.5
+tensordict>=0.6.1
+peft==0.17.0
+vector-quantize-pytorch
+matplotlib
+gguf==0.17.1
+flash-linear-attention==0.4.1
+ftfy
+piexif
+nvidia-ml-py
+misaki
+gitdb==4.0.12
+gitpython==3.1.45
+stringzilla==4.0.14
+xxhash
+munch
+wetext==0.1.2
+markdown
+Pillow
+safetensors
+https://github.com/deepbeepmeep/smplfitter/releases/download/v0.2.10/smplfitter-0.2.10-py3-none-any.whl
+https://github.com/deepbeepmeep/chumpy/releases/download/v0.71/chumpy-0.71-py3-none-any.whl