YuE2-Jam: run m-a-p/YuE2-3B instead of MiniMax Music 3, rebrand for YuE2

- engine.py: official yue2_infer package (installed --no-deps from the model repo),
ABC score planning + semantic tokens + flow matching + resident YuE2-Vae decoder;
duration caps the render (fade-out at the cap), tag-only lyrics render instrumentals
with cot="off"
- composer.py: LLM writes a YuE2 style line + [Verse]/[Chorus]-tagged lyrics
- app.py: /generate takes style instead of caption, MP3 output (WAV fallback),
Mike0021/yue2-jam-community bucket, default ZeroGPU size
- index.html/README: YuE mark + YuE2 lockup, YuE2 links, 3 min option

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

README.md

@@ -1,51 +1,60 @@
 ---
-title: MiniMax-Music3-Jam
+title: YuE2-Jam
 emoji: 🎤
-colorFrom: pink
+colorFrom: yellow
 colorTo: red
 sdk: gradio
 sdk_version: 6.24.0
 app_file: app.py
 pinned: false
-license: mit
-short_description: Describe any song, MiniMax Music 3 writes & sings it
+license: cc-by-nc-4.0
+short_description: Describe any song, YuE2 writes & sings it
 startup_duration_timeout: 1h
 suggested_hardware: zero-a10g
 models:
-  - MiniMaxAI/MiniMax-Music3
+  - m-a-p/YuE2-3B
+  - m-a-p/YuE2-Vae
   - Tongyi-MAI/Z-Image-Turbo
 tags:
   - mcp-server
 ---
 
-# MiniMax-Music3-Jam
+# YuE2-Jam
 
-Describe any song in plain English. An LLM writes the title, the tagged lyrics and the three-part
-structured caption (Global Metadata / Vocal Details / Arrangement) from the official prompting guide,
-then [MiniMax Music 3](https://huggingface.co/MiniMaxAI/MiniMax-Music3) generates the full song with
-vocals. Songs can be shared to a community feed (stored in the `victor/minimax-music3-community` bucket,
-each with its creation date).
+Describe any song in plain English. An LLM writes the title, a YuE2 style prompt and section-tagged
+lyrics, then [YuE2-3B](https://huggingface.co/m-a-p/YuE2-3B) plans a melody-and-chords score and
+sings the full song (48 kHz stereo). Songs can be shared to a community feed (stored in the
+`Mike0021/yue2-jam-community` bucket, each with its creation date).
 
 ## How it works
 
 - **Compose** (CPU): `composer.py` calls an LLM on the HF Inference Router and returns
-  `{title, tags, lyrics, global_metadata, vocal_details, arrangement}`.
-- **Sing** (ZeroGPU): `engine.py` is the diffusers `ModularPipeline` port of MiniMax Music 3 with the
-  AoTI kernels from `diffusers-internal-dev/MiniMax-Music3-aoti` (same path as the official Space).
+  `{title, tags, style, lyrics}`: `style` is a line of comma-separated descriptors (language, genre,
+  singer, instruments, mood, BPM) as in the official examples; `lyrics` use YuE2's section tags
+  (`[Intro]`, `[Verse]`, `[Pre-Chorus]`, `[Chorus]`, `[Bridge]`, `[Interlude]`, `[Outro]`).
+- **Sing** (ZeroGPU): `engine.py` runs the official `yue2_infer` package from the model repo
+  (installed with `--no-deps`; see `requirements.txt`): ABC score planning (`cot="full"`), 25 Hz
+  semantic tokens, flow matching, then the [YuE2-Vae](https://huggingface.co/m-a-p/YuE2-Vae) decoder.
+  YuE2 sets the song length from the lyrics; the requested duration caps it (fade-out if the cap is
+  hit). Lyrics made only of section tags render an instrumental without a score plan (`cot="off"`).
   Cover art comes from Z-Image-Turbo in the same GPU allocation.
-- **Share**: WAV + cover + `meta.json` are written to the bucket mounted at `/data`; the feed is served
+- **Share**: MP3 + cover + `meta.json` are written to the bucket mounted at `/data`; the feed is served
   from memory.
 
 ## API
 
 - `POST /create(description, audio_duration, seed, community, instrumental)` streams status JSON then the
-  final result `{audio, title, tags, lyrics, caption, seed, duration, created_at, thumbnail?, community_url?}`.
-- `POST /generate(caption, lyrics, audio_duration, seed, title, tags, community)` for explicit inputs.
+  final result `{audio, title, tags, lyrics, style, seed, duration, created_at, thumbnail?, community_url?}`.
+- `POST /generate(style, lyrics, audio_duration, seed, title, tags, community, cover_word)` for explicit inputs.
 - `POST /community()` returns the newest shared songs.
 
 The same three endpoints are also exposed as MCP tools (`create`, `generate`, `community`) via Gradio's
 built-in `mcp_server=True` — schema and description come straight from each function's type hints and
-docstring, no extra code. MCP endpoint (streamable HTTP): `https://victor-minimax-music3-jam.hf.space/gradio_api/mcp`
+docstring, no extra code. MCP endpoint (streamable HTTP): `https://mike0021-yue2-jam.hf.space/gradio_api/mcp`
 (legacy SSE transport at `/gradio_api/mcp/sse`; add `?tools=create,community` to either to expose only a subset).
 
-Requires the `HF_TOKEN` secret (composer LLM) and the bucket volume `hf://buckets/victor/minimax-music3-community:/data`.
+Requires the `HF_TOKEN` secret (composer LLM) and the bucket volume `hf://buckets/Mike0021/yue2-jam-community:/data`.
+
+YuE2 weights are released under [CC BY-NC 4.0](https://huggingface.co/m-a-p/YuE2-3B/blob/main/LICENSE):
+non-commercial use only. The header mark is the YuE logo (Apache 2.0) from the
+[YuE2 project page](https://map-yue2.github.io/).

app.py

@@ -1,6 +1,6 @@
-"""MiniMax-Music3-Jam: describe a song in plain English, an LLM writes the lyrics and the
-structured caption, MiniMax Music 3 sings it, and the song can be shared to a community feed
-backed by an HF bucket mounted at /data."""
+"""YuE2-Jam: describe a song in plain English, an LLM writes the lyrics and the style prompt,
+YuE2 plans a score and sings it, and the song can be shared to a community feed backed by an HF
+bucket mounted at /data."""
 
 import os
 
@@ -17,6 +17,7 @@ import base64  # noqa: E402
 import io  # noqa: E402
 import json  # noqa: E402
 import random  # noqa: E402
+import subprocess  # noqa: E402
 import time  # noqa: E402
 import traceback  # noqa: E402
 import uuid  # noqa: E402
@@ -30,17 +31,17 @@ import gradio as gr  # noqa: E402
 from gradio import Server  # noqa: E402
 
 import composer  # noqa: E402
-import engine  # noqa: E402  (loads MiniMax Music 3 + AoTI kernels onto the GPU)
+import engine  # noqa: E402  (loads YuE2-3B + YuE2-Vae onto the GPU)
 
 _HERE = os.path.dirname(os.path.abspath(__file__))
-BUCKET_ID = os.environ.get("COMMUNITY_BUCKET", "victor/minimax-music3-community")
+BUCKET_ID = os.environ.get("COMMUNITY_BUCKET", "Mike0021/yue2-jam-community")
 BUCKET_URL = f"https://huggingface.co/buckets/{BUCKET_ID}/resolve"
 DATA_DIR = os.environ.get("COMMUNITY_DIR", "/data")
 SONGS_DIR = os.path.join(DATA_DIR, "songs")
 MAX_SEED = int(np.iinfo(np.int32).max)
 MAX_DURATION = 180.0
-STEPS, GUIDANCE = 30, 1.7
 FEED_LIMIT = 60
+AUDIO_MIME = {"mp3": "audio/mpeg", "wav": "audio/wav"}
 
 print(f"[startup] model ready: sr={engine.SAMPLE_RATE} frame_rate={engine.FRAME_RATE}", flush=True)
 print(f"[startup] community bucket: {BUCKET_ID} mounted at {DATA_DIR} (exists={os.path.isdir(DATA_DIR)})", flush=True)
@@ -81,16 +82,16 @@ def _render_cover(word: str) -> bytes | None:
 
 
 # ── GPU job: song (+ optional cover) in a single ZeroGPU allocation ───────────
-def _gpu_seconds(caption, lyrics, duration, seed, cover_word, *args, **kwargs):
-    return engine.estimate_gpu_seconds(duration, STEPS) + (12 if cover_word else 0)
+def _gpu_seconds(style, lyrics, duration, seed, cover_word, *args, **kwargs):
+    return engine.estimate_gpu_seconds(duration) + (12 if cover_word else 0)
 
 
-@spaces.GPU(duration=_gpu_seconds, size="xlarge")
-def _gpu_job(caption, lyrics, duration, seed, cover_word):
+@spaces.GPU(duration=_gpu_seconds)
+def _gpu_job(style, lyrics, duration, seed, cover_word):
     # Errors are returned as data: exceptions raised in the ZeroGPU worker reach the caller
     # stripped down to their class name.
     try:
-        wav, sr, audio_seconds, wall = engine.generate_wav(caption, lyrics, duration, seed, STEPS, GUIDANCE)
+        wav, sr, audio_seconds, wall = engine.generate_wav(style, lyrics, duration, seed)
     except Exception as e:  # noqa: BLE001
         print(f"[gpu ERROR] {type(e).__name__}: {e}\n{traceback.format_exc()}", flush=True)
         return {"error": f"{type(e).__name__}: {e}"}
@@ -103,10 +104,21 @@ class GenerationError(RuntimeError):
     pass
 
 
-def _wav_bytes(wav: np.ndarray, sr: int) -> bytes:
+def _encode_audio(wav: np.ndarray, sr: int) -> tuple[bytes, str]:
+    """MP3 at 192 kbps (a 3-minute 48 kHz stereo WAV is ~35 MB), WAV if ffmpeg fails. Returns (bytes, ext)."""
+    try:
+        out = subprocess.run(
+            ["ffmpeg", "-hide_banner", "-loglevel", "error", "-f", "s16le", "-ar", str(sr), "-ac", str(wav.shape[1]),
+             "-i", "pipe:0", "-codec:a", "libmp3lame", "-b:a", "192k", "-f", "mp3", "pipe:1"],
+            input=np.ascontiguousarray(wav).tobytes(), capture_output=True, check=True, timeout=120,
+        ).stdout
+        if out:
+            return out, "mp3"
+    except (OSError, subprocess.SubprocessError) as e:
+        print(f"[encode] mp3 failed, falling back to WAV: {e}", flush=True)
     buf = io.BytesIO()
     scipy.io.wavfile.write(buf, sr, wav)
-    return buf.getvalue()
+    return buf.getvalue(), "wav"
 
 
 def _friendly_error(err: Exception) -> str:
@@ -115,8 +127,6 @@ def _friendly_error(err: Exception) -> str:
         return "The shared GPU is at capacity right now. Please wait a minute and retry."
     if "out of memory" in msg or "oom" in msg:
         return "Generation ran out of GPU memory. Try a shorter duration."
-    if "zero audio frames" in msg:
-        return "The model produced no audio for these inputs; try different lyrics or a longer duration."
     if isinstance(err, GenerationError):
         return "Generation failed on the GPU. Please try again (a shorter duration helps if it repeats)."
     if isinstance(err, (ValueError, RuntimeError)) and str(err):
@@ -129,7 +139,7 @@ _feed: list[dict] = []
 
 
 def _public_meta(meta: dict) -> dict:
-    keys = ("id", "title", "tags", "description", "lyrics", "caption", "duration", "audio_url", "thumb_url", "created_at", "seed")
+    keys = ("id", "title", "tags", "description", "lyrics", "style", "duration", "audio_url", "thumb_url", "created_at", "seed")
     return {k: meta.get(k) for k in keys}
 
 
@@ -145,7 +155,7 @@ def _load_feed():
         try:
             with open(meta_path) as f:
                 meta = json.load(f)
-            meta["audio_url"] = f"{BUCKET_URL}/songs/{song_id}/{song_id}.wav"
+            meta["audio_url"] = f"{BUCKET_URL}/songs/{song_id}/{meta.get('audio_file') or song_id + '.wav'}"
             if os.path.isfile(os.path.join(SONGS_DIR, song_id, "thumb.png")):
                 meta["thumb_url"] = f"{BUCKET_URL}/songs/{song_id}/thumb.png"
             else:
@@ -160,13 +170,14 @@ def _load_feed():
 _load_feed()
 
 
-def _share(wav_bytes: bytes, cover: bytes | None, meta: dict) -> dict:
+def _share(audio: bytes, ext: str, cover: bytes | None, meta: dict) -> dict:
     """Persist a song to the bucket mount and prepend it to the in-memory feed."""
     song_id = uuid.uuid4().hex[:12]
     song_dir = os.path.join(SONGS_DIR, song_id)
     os.makedirs(song_dir, exist_ok=True)
-    with open(os.path.join(song_dir, f"{song_id}.wav"), "wb") as f:
-        f.write(wav_bytes)
+    audio_file = f"{song_id}.{ext}"
+    with open(os.path.join(song_dir, audio_file), "wb") as f:
+        f.write(audio)
     thumb_url = None
     if cover:
         with open(os.path.join(song_dir, "thumb.png"), "wb") as f:
@@ -175,7 +186,8 @@ def _share(wav_bytes: bytes, cover: bytes | None, meta: dict) -> dict:
     meta = {
         **meta,
         "id": song_id,
-        "audio_url": f"{BUCKET_URL}/songs/{song_id}/{song_id}.wav",
+        "audio_file": audio_file,
+        "audio_url": f"{BUCKET_URL}/songs/{song_id}/{audio_file}",
         "thumb_url": thumb_url,
         "created_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
     }
@@ -188,7 +200,7 @@ def _share(wav_bytes: bytes, cover: bytes | None, meta: dict) -> dict:
 
 
 # ── gr.Server app ────────────────────────────────────────────────────────────
-app = Server(title="MiniMax-Music3-Jam")
+app = Server(title="YuE2-Jam")
 
 
 def _clamp_duration(d) -> float:
@@ -207,34 +219,34 @@ def _resolve_seed(seed) -> int:
     return random.randint(0, MAX_SEED) if seed < 0 else min(seed, MAX_SEED)
 
 
-def _run_song(*, description, title, tags, caption, lyrics, duration, seed, community, cover_word):
+def _run_song(*, description, title, tags, style, lyrics, duration, seed, community, cover_word):
     """Shared tail of /create and /generate: GPU job, encode, optional share. Returns result dict."""
-    engine.validate(caption, lyrics)
-    out = _gpu_job(caption, lyrics, duration, seed, cover_word)
+    engine.validate(style, lyrics)
+    out = _gpu_job(style, lyrics, duration, seed, cover_word)
     if out.get("error"):
         msg = out["error"]
         if "out of memory" in msg.lower():
             raise GenerationError("out of memory")
         raise GenerationError(msg)
     wav, sr, audio_seconds, cover = out["wav"], out["sr"], out["seconds"], out["cover"]
-    wav_bytes = _wav_bytes(wav, sr)
+    audio, ext = _encode_audio(wav, sr)
     result = {
         "title": title,
         "tags": tags,
         "lyrics": lyrics,
-        "caption": caption,
+        "style": style,
         "seed": seed,
         "duration": round(audio_seconds, 1),
         "created_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
-        "audio": "data:audio/wav;base64," + base64.b64encode(wav_bytes).decode(),
+        "audio": f"data:{AUDIO_MIME[ext]};base64," + base64.b64encode(audio).decode(),
     }
     if cover:
         result["thumbnail"] = "data:image/png;base64," + base64.b64encode(cover).decode()
     if community:
         try:
-            shared = _share(wav_bytes, cover, {
+            shared = _share(audio, ext, cover, {
                 "title": title, "tags": tags, "description": description, "lyrics": lyrics,
-                "caption": caption, "duration": round(audio_seconds, 1), "seed": seed,
+                "style": style, "duration": round(audio_seconds, 1), "seed": seed,
             })
             result["community_url"] = shared["audio_url"]
             result["id"] = shared["id"]
@@ -253,9 +265,9 @@ def create(
     community: bool = False,
     instrumental: bool = False,
 ) -> str:
-    """One-box: describe a song -> LLM writes title/lyrics/structured caption -> MiniMax Music 3 generates it.
+    """One-box: describe a song -> LLM writes title/style/lyrics -> YuE2 plans a score and sings it.
     Streams JSON status messages ({"status": ...}) and finally the result
-    ({audio, title, tags, lyrics, caption, seed, duration, created_at, thumbnail?, community_url?})."""
+    ({audio, title, tags, lyrics, style, seed, duration, created_at, thumbnail?, community_url?})."""
     try:
         description = (description or "").strip()
         if not description:
@@ -263,7 +275,7 @@ def create(
         duration = _clamp_duration(audio_duration)
         seed = _resolve_seed(seed)
 
-        yield json.dumps({"status": "composing", "message": "Writing lyrics & structured caption…"})
+        yield json.dumps({"status": "composing", "message": "Writing lyrics & style…"})
         t0 = time.time()
         song = composer.compose(description, duration, instrumental=bool(instrumental))
         print(f"[create] composed '{song['title']}' in {time.time() - t0:.1f}s | tags={song['tags']}", flush=True)
@@ -271,12 +283,12 @@ def create(
 
         yield json.dumps({
             "status": "generating",
-            "message": f"MiniMax Music 3 is recording “{song['title']}”…",
+            "message": f"YuE2 is scoring & recording “{song['title']}”…",
             "title": song["title"], "tags": song["tags"], "lyrics": song["lyrics"],
-            "eta": engine.estimate_gpu_seconds(duration, STEPS),
+            "eta": engine.eta_seconds(duration),
         })
         result = _run_song(
-            description=description, title=song["title"], tags=song["tags"], caption=song["caption"],
+            description=description, title=song["title"], tags=song["tags"], style=song["style"],
             lyrics=song["lyrics"], duration=duration, seed=seed, community=bool(community), cover_word=cover_word,
         )
         yield json.dumps(result)
@@ -287,7 +299,7 @@ def create(
 
 @app.api(name="generate", concurrency_limit=None, time_limit=900)
 def generate(
-    caption: str,
+    style: str,
     lyrics: str,
     audio_duration: float = 60.0,
     seed: int = -1,
@@ -296,8 +308,12 @@ def generate(
     community: bool = False,
     cover_word: str = "",
 ) -> str:
-    """Advanced: generate from an explicit structured caption + tagged lyrics (no LLM).
-    cover_word: optional visual noun for the Z-Image cover art. Returns the same JSON result shape as /create."""
+    """Advanced: generate from an explicit style prompt + section-tagged lyrics (no LLM).
+    style: comma-separated descriptors (language, genre, singer, instruments, mood, BPM), e.g. "English, warm
+    piano pop, expressive female voice, acoustic piano, light drums, 88 BPM". lyrics: [Verse]/[Chorus]/... tags
+    each on their own line; tags with no words render an instrumental. audio_duration: target length in seconds
+    (YuE2 sets the length from the lyrics; this caps it). cover_word: optional visual noun for the Z-Image
+    cover art. Returns the same JSON result shape as /create."""
     try:
         duration = _clamp_duration(audio_duration)
         seed = _resolve_seed(seed)
@@ -305,7 +321,7 @@ def generate(
         title = (title or "").strip()[:80] or "Untitled"
         tags = (tags or "").strip()[:120]
         result = _run_song(
-            description="", title=title, tags=tags, caption=(caption or "").strip(), lyrics=lyrics,
+            description="", title=title, tags=tags, style=" ".join((style or "").split()), lyrics=lyrics,
             duration=duration, seed=seed, community=bool(community),
             cover_word=(cover_word or "").strip()[:40] if _zimage else "",
         )
@@ -327,9 +343,9 @@ async def homepage():
         return f.read()
 
 
-@app.get("/logo.png", include_in_schema=False)
+@app.get("/logo.svg", include_in_schema=False)
 async def logo():
-    return FileResponse(os.path.join(_HERE, "logo_dark.png"), media_type="image/png")
+    return FileResponse(os.path.join(_HERE, "logo.svg"), media_type="image/svg+xml")
 
 
 demo = app

composer.py

@@ -1,8 +1,8 @@
-"""LLM composer: plain-English song description -> MiniMax Music 3 inputs.
+"""LLM composer: plain-English song description -> YuE2 inputs.
 
-Produces a title, short display tags, tagged lyrics and the three-part Structured Caption
-(Global Metadata / Vocal Details / Arrangement) the model was trained on, following the
-official prompting guide. Runs on the HF Inference Router (no GPU).
+Produces a title, short display tags, a YuE2 style prompt (comma-separated descriptors: language,
+genre, singer, instruments, mood, tempo, as in the official examples) and section-tagged lyrics.
+Runs on the HF Inference Router (no GPU).
 """
 
 import json
@@ -30,31 +30,34 @@ VISUAL_MODELS = (
     ("deepseek-ai/DeepSeek-V4-Flash-0731:fastest", 45, _NO_THINK),
 )
 
-_CAPTION_CONTRACT = """The three caption fields follow the exact labeled style the model was trained on. Be concrete and musical; describe an energy arc and instrument lifecycles, never a static equipment list or decorative adjectives. Never contradict an explicit user constraint: instrumental stays instrumental; never reverse a required vocal gender, tempo limit, required instrument, or exclusion. Do not quote or paraphrase lyric lines inside the caption. Total caption length roughly 250-400 words.
+# YuE2's native section labels (the ABC planner marks the same sections in its score).
+SECTIONS = ("Intro", "Verse", "Pre-Chorus", "Chorus", "Bridge", "Interlude", "Instrumental", "Outro")
+_SECTION_ALIASES = {
+    "pre chorus": "Pre-Chorus", "prechorus": "Pre-Chorus", "post-chorus": "Chorus", "post chorus": "Chorus",
+    "hook": "Chorus", "refrain": "Chorus", "break": "Interlude", "solo": "Interlude", "inst": "Instrumental",
+}
+_SECTION_NAMES = {s.lower(): s for s in SECTIONS} | _SECTION_ALIASES
+NO_VOCALS = "no vocals, no singing, no choir, no spoken words"
 
-global_metadata: one paragraph, in order: "Basic Attributes: bpm is <number>. key is <letter>, and scale is <major|minor>. <Genre / Subgenre>." then "Global Emotional Progression: <how the emotion evolves from the opening through the final section>." then "Application Scenarios & Imagery: <two or three vivid listening scenarios>." then "Sonics & Production Profile: <soundstage, frequency balance, dynamics, production character>."
+_STYLE_RULES = f"""style: ONE line of 8-14 comma-separated musical descriptors, like the official YuE2 examples: start with the lyrics language ("English", "Mandarin Chinese", ...), then genre and subgenre, the singer (gender, timbre, delivery, e.g. "breathy female voice", "gritty male baritone"), 3-5 key instruments each with a short character ("rounded electric bass", "gated snare"), mood and energy arc, production character, and the tempo as "<number> BPM". Example: "English, warm piano pop, expressive female voice, acoustic piano, rounded bass and light drums, lyrical memorable melody, unhurried phrasing, 88 BPM". Plain musical words only: no sentences, quotes, title or lyric lines. Never contradict an explicit user constraint (vocal gender, tempo, required or excluded instruments). For an instrumental, start with "Instrumental" instead of a language, name the instrument carrying the melody, and end with "{NO_VOCALS}"."""
 
-vocal_details: one paragraph: "Vocal Gender & Timbre: Singer A (<Male|Female>), <timbre and register>." then "Vocal Style: <delivery, and how it shifts per section>." then "Harmony/Backing Vocals: <where harmonies or doubles appear and their character>." then "Vocal FX: <restrained treatment: reverb, delay, light compression>." For instrumental pieces write "Instrumental, no vocals." and name the instrument or texture carrying the lead melodic role.
+_LYRICS_RULES = """lyrics: singable lyrics using ONLY these section tags: [Intro] [Verse] [Pre-Chorus] [Chorus] [Bridge] [Interlude] [Outro]. Each tag ALONE on its own line with the section's lines below it, and one blank line between sections. [Intro] and [Interlude] are usually left empty (instrumental passages). Size the structure to the duration: <=30s: one [Verse] + one [Chorus]; ~60s: [Intro] [Verse] [Chorus] [Verse] [Chorus]; ~120s: [Intro] [Verse] [Pre-Chorus] [Chorus] [Verse] [Pre-Chorus] [Chorus] [Bridge] [Chorus] [Outro]; >=180s: that full structure plus an [Interlude] and a final repeated [Chorus]. 4 lines per sung section, short rhythmic lines of 5-9 words, roughly 12-16 sung words per 10 seconds; repeat the chorus words each time it returns. Musical instructions (tempo, instruments, dynamics) never belong in the lyrics. Write in the language the user asks for (default: English; YuE2 is strongest in English and Mandarin Chinese). If the song is instrumental, the lyrics are ONLY the section tags, with no words."""
 
-arrangement: one paragraph: "Instrument Lifecycle Description (Primary/Secondary Layering): Primary: <core instruments present start to finish and their role>. Secondary: <instruments that enter, exit or intensify, and in which sections>." then "Groove & Foundation Progression: <how drums, bass and groove develop across sections>." then "Embellishments, Textures & Spatial FX: <fills, textures, transitional gestures, stereo and space treatment where relevant>." State what enters, exits, changes or intensifies for every section of the song, aligned with the lyric section tags."""
-
-_LYRICS_RULES = """lyrics: singable lyrics using ONLY these section tags, each ALWAYS ALONE on its own line: [intro] [verse] [pre-chorus] [chorus] [post-chorus] [bridge] [instrumental] [solo] [outro]. Never put words on the same line as a tag. Size the structure to the duration: <=30s: one verse + one chorus; ~60s: verse/pre-chorus/chorus/verse/chorus; >=120s: full structure with bridge and outro. Roughly 12-16 sung words per 10 seconds. Musical instructions (tempo, instruments, dynamics) never belong in the lyrics. If the song is instrumental, use [instrumental] sections with no words. Write the lyrics in the language the user asks for (default: English)."""
-
-COMPOSER_SYSTEM = f"""You write inputs for MiniMax Music 3, a lyrics+description music generation model.
+COMPOSER_SYSTEM = f"""You write inputs for YuE2, an open music generation model that sings complete songs from a style prompt and section-tagged lyrics.
 Given a song description and a target duration, produce:
 1. title: a short, catchy song title (2-5 words, no quotes).
 2. tags: 3-5 short comma-separated style tags for a music feed card, e.g. "synth-pop, female vocals, 120 bpm, euphoric".
-3. {_LYRICS_RULES}
-4-6. global_metadata, vocal_details, arrangement: a structured caption. {_CAPTION_CONTRACT}
-Unless the user explicitly asks for an instrumental, the song HAS a singer: vocal_details must describe that singer (gender, timbre, style) and must never say "Instrumental".
-Answer with ONLY a JSON object with keys: title, tags, lyrics, global_metadata, vocal_details, arrangement. Inside the lyrics string, separate lines with JSON newline escapes, never with the two literal characters backslash and n."""
+3. {_STYLE_RULES}
+4. {_LYRICS_RULES}
+Unless the user explicitly asks for an instrumental, the song HAS a singer: the style must describe that singer and the lyrics must have words to sing.
+Answer with ONLY a JSON object with keys: title, tags, style, lyrics. Inside the lyrics string, separate lines with JSON newline escapes, never with the two literal characters backslash and n."""
 
 VISUAL_SYSTEM = (
     "Reply with exactly ONE concrete visual noun (a physical object, animal, or natural element) "
     "that captures the essence of this song. No explanation, no punctuation, just the single word."
 )
 
-SECTION_TAG_RE = re.compile(r"^\s*\[(intro|verse|pre-chorus|chorus|post-chorus|bridge|instrumental|solo|outro)\]\s*$", re.I)
+_TAG_LINE_RE = re.compile(r"^\s*\[([^\]]*)\]\s*(.*)$")
 
 
 def _client():
@@ -101,38 +104,47 @@ def _parse_json(text, required):
     return data
 
 
+def _section_tag(label: str) -> str:
+    """Canonical YuE2 tag: "verse 2" -> [Verse], "pre chorus" -> [Pre-Chorus], "hook" -> [Chorus]."""
+    key = re.sub(r"\s+", " ", re.sub(r"[\s_:-]*\d+$", "", label.strip().lower()))
+    return f"[{_SECTION_NAMES.get(key, label.strip().title())}]"
+
+
 def normalize_lyrics(lyrics: str) -> str:
-    """Put every section tag alone on its own line (the model drops words that share a tag's line)."""
+    """Canonical tags, each alone on its own line, with a blank line between sections."""
     out = []
     text = (lyrics or "").replace("\r", "").replace("\\n", "\n")
     for line in text.split("\n"):
-        m = re.match(r"^\s*(\[[^\]]+\])\s*(.*)$", line)
-        if m and m.group(2).strip():
-            out.append(m.group(1).lower())
-            out.append(m.group(2).strip())
-        elif m:
-            out.append(m.group(1).lower())
+        m = _TAG_LINE_RE.match(line)
+        if m and m.group(1).strip():
+            out += ["", _section_tag(m.group(1))]
+            if m.group(2).strip():
+                out.append(m.group(2).strip())
         else:
             out.append(line.rstrip())
     text = "\n".join(out)
     return re.sub(r"\n{3,}", "\n\n", text).strip()
 
 
+def has_words(lyrics: str) -> bool:
+    return any(line.strip() and not _TAG_LINE_RE.match(line) for line in (lyrics or "").split("\n"))
+
+
 def compose(description: str, duration: float, instrumental: bool = False) -> dict:
-    """Return {title, tags, lyrics, caption, global_metadata, vocal_details, arrangement}."""
+    """Return {title, tags, style, lyrics}."""
     user = f"Song description: {description.strip()}\nTarget duration: {int(duration)} seconds."
     if instrumental:
-        user += "\nThis song is INSTRUMENTAL: no vocals at all. Use [instrumental] sections only, with no words."
+        user += "\nThis song is INSTRUMENTAL: no vocals at all. The lyrics are section tags only, with no words."
     else:
         user += "\nThe song has sung vocals (pick a fitting singer if the description does not specify one)."
-    required = ("title", "lyrics", "global_metadata", "vocal_details", "arrangement")
+    required = ("title", "style", "lyrics")
     last_error = None
     for _ in range(2):
         try:
             data = _parse_json(_chat(COMPOSER_SYSTEM, user), required)
-            vd = str(data["vocal_details"]).lower()
-            if not instrumental and vd.startswith("instrumental"):
-                raise ValueError("vocal_details says instrumental for a vocal song")
+            lyrics = normalize_lyrics(str(data["lyrics"]))
+            if not instrumental and not has_words(lyrics):
+                raise ValueError("no sung words in the lyrics of a vocal song")
             break
         except (ValueError, json.JSONDecodeError) as e:
             print(f"[composer] bad reply: {e}", flush=True)
@@ -140,24 +152,18 @@ def compose(description: str, duration: float, instrumental: bool = False) -> di
     else:
         raise RuntimeError("The composer returned an unusable reply; please try again.") from last_error
 
-    lyrics = normalize_lyrics(str(data["lyrics"]))
-    if instrumental and not any(SECTION_TAG_RE.match(l) for l in lyrics.split("\n")):
-        lyrics = "[instrumental]\n\n" + lyrics
+    style = " ".join(str(data["style"]).split()).strip().strip('"\'')
+    if instrumental:
+        # Section tags only: the engine renders tag-only lyrics without a vocal line.
+        tags_only = [l for l in lyrics.split("\n") if _TAG_LINE_RE.match(l)]
+        lyrics = "\n\n".join(tags_only) or "[Instrumental]"
+        if not style.lower().startswith("instrumental"):
+            style = f"Instrumental, {style}"
+        if "no vocals" not in style.lower():
+            style = f"{style.rstrip(' ,.')}, {NO_VOCALS}"
     title = str(data["title"]).strip().strip('"\'')[:80] or "Untitled"
     tags = str(data.get("tags", "")).strip().strip(".")[:120]
-    global_metadata = str(data["global_metadata"]).strip()
-    vocal_details = str(data["vocal_details"]).strip()
-    arrangement = str(data["arrangement"]).strip()
-    caption = "\n".join(s for s in (global_metadata, vocal_details, arrangement) if s)
-    return {
-        "title": title,
-        "tags": tags,
-        "lyrics": lyrics,
-        "caption": caption,
-        "global_metadata": global_metadata,
-        "vocal_details": vocal_details,
-        "arrangement": arrangement,
-    }
+    return {"title": title, "tags": tags, "style": style, "lyrics": lyrics}
 
 
 def visual_word(title: str, tags: str, lyrics: str, description: str) -> str:

engine.py

@@ -1,293 +1,143 @@
-"""MiniMax Music 3 inference engine for ZeroGPU.
+"""YuE2-3B inference engine for ZeroGPU.
 
-Ported from the official MiniMaxAI/MiniMax-Music3 Space (diffusers ModularPipeline +
-AoTI kernels compiled for the RTX Pro 6000 ZeroGPU hardware). Everything here runs at
-import time (model load + AoTI binding) except `generate_wav`, which must be called from
-inside a `@spaces.GPU` function.
+Wraps the official `yue2_infer` package shipped in the m-a-p/YuE2-3B repo: one AR/NAR backbone
+plans a chord-annotated ABC score, writes 25 Hz semantic tokens, turns them into acoustic latents
+by flow matching, and YuE2-Vae decodes 48 kHz stereo. Everything here runs at import time (model
+load) except `generate_wav`, which must be called from inside a `@spaces.GPU` function.
 """
 
-import copy as _copy
+import re
+import subprocess
+import sys
 import time
 
-import spaces  # must precede torch (ZeroGPU patches CUDA init)
+import spaces  # noqa: F401  must precede torch (ZeroGPU patches CUDA init)
 import numpy as np
 import torch
-import torch.nn as _nn
-from huggingface_hub import snapshot_download
 
-from diffusers import ModularPipeline
-from diffusers.models.modeling_outputs import Transformer2DModelOutput
-from transformers import StaticCache
-from transformers.integrations.executorch import TorchExportableModuleForDecoderOnlyLM
+MODEL_ID = "m-a-p/YuE2-3B"
+VAE_ID = "m-a-p/YuE2-Vae"
+# The inference package lives in the model repo. Its metadata hard-pins huggingface-hub 0.x, which
+# Gradio 6 cannot run with, so it goes in without dependencies (the real ones are in requirements.txt).
+WHEEL_URL = f"https://huggingface.co/{MODEL_ID}/resolve/main/yue2_infer-0.1.5-py3-none-any.whl"
 
-MODEL_ID = "MiniMaxAI/MiniMax-Music3"
-AOTI_ID = "diffusers-internal-dev/MiniMax-Music3-aoti"
+try:
+    import yue2  # noqa: F401
+except ImportError:
+    subprocess.run([sys.executable, "-m", "pip", "install", "--no-deps", "-q", WHEEL_URL], check=True)
 
-PIPE = ModularPipeline.from_pretrained(MODEL_ID)
-PIPE.load_components(dtype=torch.bfloat16)
-PIPE.to("cuda")
+from yue2 import YuE2Pipeline  # noqa: E402
+from yue2.modeling_vae import YuE2VAE  # noqa: E402
+from yue2.modeling_yue2 import YuE2ForCausalLM  # noqa: E402
+from yue2.protocol import CONTEXT, SongRequest, token_prefixes  # noqa: E402
 
-SAMPLE_RATE = int(PIPE.sampling_rate)
-FRAME_RATE = float(PIPE.frame_rate)
-MAX_FRAMES = 9000
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 
+# YuE2Pipeline.__init__ caps the process at a 24 GiB memory fraction, which forces a real CUDA init
+# under ZeroGPU's startup emulation; skip only that cap.
+_set_memory_fraction = torch.cuda.set_per_process_memory_fraction
+torch.cuda.set_per_process_memory_fraction = lambda *args, **kwargs: None
+try:
+    PIPE = YuE2Pipeline.from_pretrained(MODEL_ID, vae=VAE_ID, device=DEVICE, progress=False)
+finally:
+    torch.cuda.set_per_process_memory_fraction = _set_memory_fraction
 
-def _encode_prompt(caption, lyrics, device):
-    # Mirrors the modular TextEncoderStep: the AR stage is driven manually below.
-    import diffusers.modular_pipelines.minimax_music3.encoders as P
+# Weights are loaded here rather than lazily by the pipeline: transformers 5 takes `dtype` (the
+# package passes `torch_dtype`), and the VAE stays resident next to the backbone, whereas the
+# package's decode() moves the 7 GB backbone to the CPU and back for every song.
+PIPE._model = YuE2ForCausalLM.from_pretrained(
+    PIPE.model_dir, local_files_only=True, dtype=torch.bfloat16
+).eval().to(DEVICE)
+VAE = YuE2VAE.from_pretrained(PIPE.vae_dir, decoder_only=True, device=DEVICE, local_files_only=True)
 
-    text = (
-        f"{P._IM_START}{P._CAPTION_START}{P._clean_caption(caption)}{P._CAPTION_END}"
-        f"{P._LYRICS_START}{P._normalize_lyrics(lyrics)}{P._LYRICS_END}{P._IM_END}{P._AUDIO_START}"
-    )
-    input_ids = PIPE.tokenizer(text, return_tensors="pt")["input_ids"]
-    if input_ids.shape[1] > P._MAX_PROMPT_TOKENS:
-        raise ValueError(
-            f"The assembled prompt has {input_ids.shape[1]} tokens; the maximum is {P._MAX_PROMPT_TOKENS}."
-        )
-    unconditional_ids = input_ids.clone()
-    unconditional_ids[:, 1:-2] = P._AUDIO_CFG_TOKEN_ID
-    return torch.cat((input_ids, unconditional_ids), dim=0).to(device)
-
-
-# ── AoTI kernels ─────────────────────────────────────────────────────────────
-# The transformer artifact is static over full 689-latent chunks; the once-per-song
-# final short chunk falls back to eager.
-_AOTI_DIR = snapshot_download(AOTI_ID)
-_eager_transformer_forward = PIPE.transformer.forward
-spaces.aoti_load_from_package_dir(PIPE.transformer, f"{_AOTI_DIR}/transformer")
-_aoti_transformer_forward = PIPE.transformer.forward
-
-
-def _guarded_transformer_forward(hidden_states, timestep, encoder_hidden_states, return_dict=True):
-    if hidden_states.shape[-1] == 689:
-        out = _aoti_transformer_forward(hidden_states, timestep, encoder_hidden_states)
-        if not isinstance(out, Transformer2DModelOutput):
-            out = Transformer2DModelOutput(sample=out[0] if isinstance(out, (tuple, list)) else out)
-        return out
-    return _eager_transformer_forward(hidden_states, timestep, encoder_hidden_states, return_dict=return_dict)
-
-
-PIPE.transformer.forward = _guarded_transformer_forward
-spaces.aoti_load_from_package_dir(PIPE.vocoder, f"{_AOTI_DIR}/vocoder")
-
-# AoTI LM decode step, one artifact per StaticCache bucket; eager per-frame glue. Eager
-# full-sequence prefill writes directly into each artifact's cache buffers (aliased
-# StaticCache), matching eager exactly.
-_LM = PIPE.language_model
-_BUCKETS = [1024, 2048, 4096, 8192]
-_STOP_CHECK_INTERVAL = 25
-
-_lm_headless = _copy.copy(_LM)
-_lm_headless._modules = dict(_LM._modules)  # nn.Module shallow copies share _modules
-_lm_headless.lm_head = _nn.Identity()
-_lm_headless.generation_config = _copy.deepcopy(_LM.generation_config)
-_lm_headless.generation_config.cache_implementation = "static"
-
-_LM_STEPS = {}
-for _bucket in _BUCKETS:
-    _exportable = TorchExportableModuleForDecoderOnlyLM(
-        _lm_headless, batch_size=2, max_cache_len=_bucket, device="cuda"
-    )
-    for _m in _exportable.modules():
-        _m._non_persistent_buffers_set.clear()
-    spaces.aoti_load_from_package_dir(_exportable.model, f"{_AOTI_DIR}/lm_step_{_bucket}")
-    _LM_STEPS[_bucket] = _exportable.model
-
-
-def _aliased_cache(step_module, bucket):
-    cache = StaticCache(max_cache_len=bucket, config=_LM.config.get_text_config())
-    cache.early_initialization(
-        2, _LM.config.num_key_value_heads, _LM.config.head_dim, _LM.dtype, torch.device("cuda")
-    )
-    for i, layer in enumerate(cache.layers):
-        layer.keys = step_module.get_buffer(f"key_cache_{i}")
-        layer.values = step_module.get_buffer(f"value_cache_{i}")
-        layer.cumulative_length = step_module.get_buffer(f"cumulative_length_{i}")
-        layer.keys.zero_()
-        layer.values.zero_()
-        layer.cumulative_length.zero_()
-    return cache
+SAMPLE_RATE = int(VAE.config.sample_rate)
+FRAME_RATE = SAMPLE_RATE / VAE.config.downsampling_ratio  # semantic tokens per second of audio
+ABC_MAX_TOKENS = PIPE.generation_config.abc.max_tokens
+ODE_STEPS = PIPE.generation_config.ode_steps
+MAX_AUDIO_SECONDS = 240.0
+MAX_STYLE_CHARS, MAX_LYRICS_CHARS = 1500, 10000
+FADE_SECONDS = 3.0
 
+_TAG_LINE = re.compile(r"^\s*\[[^\]]*\]\s*$")
 
-def _hop_lm_cache(src_bucket, dst_bucket, used):
-    src, dst = _LM_STEPS[src_bucket], _LM_STEPS[dst_bucket]
-    for i in range(_LM.config.num_hidden_layers):
-        dst.get_buffer(f"key_cache_{i}")[:, :, :used] = src.get_buffer(f"key_cache_{i}")[:, :, :used]
-        dst.get_buffer(f"value_cache_{i}")[:, :, :used] = src.get_buffer(f"value_cache_{i}")[:, :, :used]
-        dst.get_buffer(f"cumulative_length_{i}").copy_(src.get_buffer(f"cumulative_length_{i}"))
 
+def is_instrumental(lyrics: str) -> bool:
+    """True when the lyrics hold only section tags, i.e. there are no words to sing."""
+    return not any(line.strip() and not _TAG_LINE.match(line) for line in (lyrics or "").splitlines())
 
-def _iter_frames_aoti(text_ids, max_frames, generator=None):
-    import diffusers.modular_pipelines.minimax_music3.encoders as P
 
-    prompt_len = text_ids.shape[1]
-    bucket = _BUCKETS[0]
-    while bucket < prompt_len + 16:
-        bucket *= 2
-    step = _LM_STEPS[bucket]
-    cache = _aliased_cache(step, bucket)
-    prompt_embeds = _LM.model.embed_tokens(text_ids)
-    output = _LM.model(
-        inputs_embeds=prompt_embeds,
-        past_key_values=cache,
-        cache_position=torch.arange(prompt_len, device="cuda"),
-        use_cache=True,
-    )
-    last_hidden = output.last_hidden_state[:, -1]
-
-    vocab_mask = torch.ones(_LM.config.vocab_size, dtype=torch.bool, device="cuda")
-    vocab_mask[P._AUDIO_CODE_OFFSET : P._AUDIO_CODE_OFFSET + P._SEMANTIC_VOCAB_SIZE] = False
-    vocab_mask[P._AUDIO_END_TOKEN_ID] = False
-
-    emitted = 0
-    position = prompt_len
-    pending = []
-    for frame_index in range(max_frames + 1):
-        if position + 2 >= bucket:
-            new_bucket = bucket * 2
-            _hop_lm_cache(bucket, new_bucket, position)
-            bucket = new_bucket
-            step = _LM_STEPS[bucket]
-        logits = _LM.lm_head(last_hidden).float()
-        logits = logits.masked_fill(vocab_mask, -float("inf"))
-        conditional, unconditional = logits[0:1], logits[1:2]
-        guided = unconditional + (conditional - unconditional) * P._AR_CFG_SCALE
-        threshold = torch.topk(conditional, P._AR_CFG_TOP_K, dim=-1).values[..., -1, None]
-        guided = guided.masked_fill(conditional < threshold, -float("inf"))
-        guided = guided.masked_fill(vocab_mask.unsqueeze(0), -float("inf"))
-        sampled = P._sample_top_k(guided, generator)
-        semantic_code = (sampled - P._AUDIO_CODE_OFFSET).clamp_min(0).repeat(2)
-        frame_codes, depth_hidden = P._generate_depth_codes(PIPE, last_hidden, semantic_code, generator)
-        frame_hidden = torch.cat((last_hidden[:1].clone(), depth_hidden), dim=-1) if frame_index > 0 else None
-        pending.append((sampled, frame_hidden))
-        if len(pending) >= _STOP_CHECK_INTERVAL or frame_index == max_frames:
-            stop_flags = torch.cat([s == P._AUDIO_END_TOKEN_ID for s, _ in pending]).tolist()
-            for flag, (_, fh) in zip(stop_flags, pending):
-                if flag:
-                    return
-                if fh is not None:
-                    emitted += 1
-                    yield fh
-                    if emitted >= max_frames:
-                        return
-            pending = []
-        feedback = P._embed_audio_frame(PIPE, frame_codes)
-        last_hidden = step(inputs_embeds=feedback, cache_position=torch.tensor([position], device="cuda"))[:, -1]
-        position += 1
-    for _, fh in pending:
-        if fh is not None:
-            yield fh
-
-
-PIPE._iter_frames = _iter_frames_aoti
-
-
-# ── Windowed flow-matching decode + vocoder ──────────────────────────────────
-_CHUNK, _HOP, _HOP_SAMPLES = 200, 100, 86 * 512
-_CROP_RIGHT_SAMPLES = (344 - 86) * 512
+def _cot(lyrics: str) -> str:
+    # Full planning writes a melody+chords score whose lead is a Vocal voice, which YuE2 then sings;
+    # instrumentals skip the symbolic plan.
+    return "off" if is_instrumental(lyrics) else "full"
 
 
-@torch.inference_mode()
-def _decode_window(hidden_window, previous, generator, steps, guidance):
-    previous_latent, previous_condition = previous
-    condition = PIPE.condition_encoder(hidden_window)
-    condition = condition.to(PIPE.transformer.dtype)
-    latents = torch.randn(
-        (1, PIPE.transformer.config.in_channels, condition.shape[1]),
-        generator=generator, device="cuda", dtype=condition.dtype,
-    )
-    overlap, noise_prompt = 0, None
-    if previous_latent is not None:
-        overlap = min(previous_latent.shape[-1], latents.shape[-1])
-        noise_prompt = latents[..., :overlap].clone()
-        condition[:, :overlap] = previous_condition[:, :overlap]
-    condition_input = torch.cat((condition, torch.zeros_like(condition)), dim=0)
-    PIPE.scheduler.set_timesteps(sigmas=np.linspace(1.0, 1.0 / steps, steps), device="cuda")
-    for timestep in PIPE.scheduler.timesteps:
-        if overlap > 0:
-            t = timestep.to(latents.dtype)
-            latents[..., :overlap] = (1.0 - (1.0 - 1e-6) * t) * noise_prompt + t * previous_latent[..., :overlap]
-        velocity = PIPE.transformer(
-            latents.expand(2, -1, -1).contiguous(), timestep.expand(2).to(latents.dtype), condition_input
-        ).sample
-        velocity = velocity[1:2] + guidance * (velocity[0:1] - velocity[1:2])
-        latents = PIPE.scheduler.step(velocity, timestep, latents).prev_sample
-    if overlap > 0:
-        latents[..., :overlap] = previous_latent[..., :overlap]
-    overlap_start = max(0, latents.shape[-1] - 2 * 172)
-    overlap_end = max(overlap_start, latents.shape[-1] - 172)
-    carry = (latents[..., overlap_start:overlap_end], condition[:, overlap_start:overlap_end])
-    waveform = PIPE.vocoder(latents.to(PIPE.vocoder.dtype)).float().clamp(-1.0, 1.0)[0]
-    return waveform, carry
+def max_audio_seconds(duration: float) -> float:
+    """Hard cap on the rendered length. YuE2 picks the song length from the lyrics (the composer
+    sizes them to `duration`); the cap only bounds GPU time, with headroom for intros and outros."""
+    return min(float(duration) * 1.3 + 15.0, MAX_AUDIO_SECONDS)
 
 
-@torch.inference_mode()
-def _stream_windows(text_ids, max_frames, ar_generator, dit_generator, steps, guidance):
-    frames = []
-    windows_done = 0
-    carry = (None, None)
-    for hidden in PIPE._iter_frames(text_ids, max_frames, ar_generator):
-        frames.append(hidden)
-        window_start = windows_done * _HOP
-        if len(frames) > window_start + _CHUNK:
-            window = torch.stack(frames[window_start : window_start + _CHUNK], dim=1)
-            waveform, carry = _decode_window(window, carry, dit_generator, steps, guidance)
-            left = 0 if windows_done == 0 else _HOP_SAMPLES
-            windows_done += 1
-            yield waveform[:, left : waveform.shape[-1] - _CROP_RIGHT_SAMPLES]
-    if not frames:
-        raise RuntimeError("The model generated zero audio frames; try different lyrics or a longer duration.")
-    total = len(frames)
-    window_starts = [0] if total <= _CHUNK else list(range(0, total - _HOP, _HOP))
-    for w in range(windows_done, len(window_starts)):
-        window_start = window_starts[w]
-        window = torch.stack(frames[window_start : min(window_start + _CHUNK, total)], dim=1)
-        waveform, carry = _decode_window(window, carry, dit_generator, steps, guidance)
-        left = 0 if w == 0 else _HOP_SAMPLES
-        right = _CROP_RIGHT_SAMPLES if w < len(window_starts) - 1 else 0
-        yield waveform[:, left : waveform.shape[-1] - right]
+def _gpu_time(audio_seconds: float, abc_tokens: float) -> float:
+    # Fitted on ZeroGPU with this same package (hugging-apps/yue2-instrumental-cot-lora): ~104 tok/s
+    # while planning, ~0.265 s per audio-second for semantic decoding + VAE, ~0.0023 s per
+    # audio-second per ODE step, ~11 s fixed (worker start + VAE).
+    return 11.0 + abc_tokens / 104.0 + audio_seconds * (0.265 + 0.0023 * ODE_STEPS)
 
 
-def _to_int16(waveform):
-    return (waveform.cpu().numpy().T * 32767.0).astype(np.int16)
+def estimate_gpu_seconds(duration: float) -> int:
+    """ZeroGPU reservation: worst case (ABC plan at its token cap, song at its length cap) + 10%."""
+    return int(min(_gpu_time(max_audio_seconds(duration), ABC_MAX_TOKENS) * 1.1, 300))
 
 
-def estimate_gpu_seconds(duration, steps=30):
-    """Fitted on-Space (xlarge): wall = 0.75*dur + 0.20*dur*(steps/30) + ~15s cold-worker margin."""
-    return min(int(float(duration) * (0.75 + 0.20 * float(steps) / 30.0) + 15), 600)
+def eta_seconds(duration: float) -> int:
+    """Typical wall time for a song of ~`duration` seconds (plans run 1.6k-2.7k ABC tokens)."""
+    return int(_gpu_time(float(duration) * 1.1, 2200))
 
 
-def validate(caption: str, lyrics: str) -> None:
+def validate(style: str, lyrics: str) -> None:
     """CPU-side input validation (raise ValueError with a user-facing message).
 
     Runs before the ZeroGPU call: exceptions raised inside the GPU worker lose their message.
     """
-    caption = (caption or "").strip()
+    style = (style or "").strip()
     lyrics = (lyrics or "").strip()
-    if not caption:
-        raise ValueError("A music description (structured caption) is required.")
+    if not style:
+        raise ValueError("A style description is required.")
     if not lyrics:
-        raise ValueError("Lyrics are required (use [instrumental] for songs without vocals).")
-    _encode_prompt(caption, lyrics, "cpu")  # raises ValueError past the token limit
+        raise ValueError("Lyrics are required (section tags only, e.g. [Instrumental], make an instrumental).")
+    if len(style) > MAX_STYLE_CHARS:
+        raise ValueError(f"Keep the style under {MAX_STYLE_CHARS} characters.")
+    if len(lyrics) > MAX_LYRICS_CHARS:
+        raise ValueError(f"Keep the lyrics under {MAX_LYRICS_CHARS} characters.")
+    prompt_tokens = len(token_prefixes(SongRequest(style=style, lyrics=lyrics, cot=_cot(lyrics)), PIPE.tokenizer))
+    if prompt_tokens + ABC_MAX_TOKENS + 3 + int(MAX_AUDIO_SECONDS * FRAME_RATE) > CONTEXT:
+        raise ValueError("The lyrics are too long for YuE2's context window; please shorten them.")
 
 
 @torch.inference_mode()
-def generate_wav(caption: str, lyrics: str, duration: float, seed: int, steps: int = 30, guidance: float = 1.7):
-    """Run the full AR -> windowed DiT -> vocoder pipeline. Must run inside @spaces.GPU.
+def generate_wav(style: str, lyrics: str, duration: float, seed: int):
+    """Run plan -> semantic tokens -> flow matching -> VAE. Must run inside @spaces.GPU.
 
     Returns (int16 stereo ndarray [samples, 2], sample_rate, audio_seconds, wall_seconds).
     """
-    caption = (caption or "").strip()
-    lyrics = (lyrics or "").strip()
-    steps, guidance = int(steps), float(guidance)
-    text_ids = _encode_prompt(caption, lyrics, "cuda")
-    max_frames = min(int(float(duration) * FRAME_RATE), MAX_FRAMES)
-    ar_generator = torch.Generator("cuda").manual_seed(int(seed))
-    dit_generator = torch.Generator("cuda").manual_seed(int(seed) + 1)
-
+    style, lyrics = (style or "").strip(), (lyrics or "").strip()
     start = time.time()
-    chunks = list(_stream_windows(text_ids, max_frames, ar_generator, dit_generator, steps, guidance))
-    full = _to_int16(torch.cat(chunks, dim=-1))
-    audio_seconds = full.shape[0] / SAMPLE_RATE
-    return full, SAMPLE_RATE, audio_seconds, time.time() - start
+    plan = PIPE.plan(style=style, lyrics=lyrics, cot=_cot(lyrics), seed=int(seed))
+    max_tokens = int(max_audio_seconds(duration) * FRAME_RATE)
+    semantic = PIPE.generate_semantic(plan, sampling={"max_tokens": max_tokens})
+    latents = PIPE.synthesize(semantic)
+    audio = VAE.decode_tiled(
+        torch.from_numpy(latents).T.contiguous().unsqueeze(0), core_frames=1024, halo_frames=16, output_device="cpu"
+    )
+    wav = audio[0].clamp(-1.0, 1.0).T.contiguous().numpy()
+    if semantic.truncated:  # stopped at the length cap: fade out rather than cut mid-phrase
+        n = min(len(wav), int(FADE_SECONDS * SAMPLE_RATE))
+        wav[-n:] *= np.linspace(1.0, 0.0, n, dtype=np.float32)[:, None]
+    print(
+        f"[engine] cot={plan.request.cot} abc_tokens={len(plan.abc_ids)} (truncated={plan.truncated}) "
+        f"semantic_tokens={len(semantic.tokens)}/{max_tokens} (truncated={semantic.truncated}) "
+        f"abc={plan.timing.get('seconds', 0):.1f}s semantic={semantic.timing['seconds']:.1f}s",
+        flush=True,
+    )
+    return (wav * 32767.0).astype(np.int16), SAMPLE_RATE, len(wav) / SAMPLE_RATE, time.time() - start

index.html

@@ -3,9 +3,10 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>MiniMax-Music3-Jam</title>
+  <title>YuE2-Jam</title>
+  <link rel="icon" href="logo.svg" type="image/svg+xml" />
   <link rel="preconnect" href="https://fonts.googleapis.com" />
-  <link href="https://fonts.googleapis.com/css2?family=Hanken+Grotesk:wght@300;400;500;600;700&family=Outfit:wght@500&display=swap" rel="stylesheet" />
+  <link href="https://fonts.googleapis.com/css2?family=Hanken+Grotesk:wght@300;400;500;600;700&family=Space+Grotesk:wght@500;600&display=swap" rel="stylesheet" />
   <script src="https://cdn.jsdelivr.net/npm/mp4-muxer@5.1.3/build/mp4-muxer.min.js"></script>
   <style>
     *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
@@ -20,6 +21,7 @@
       --accent-dim:  oklch(0.40 0.005 260);
       --accent-glow: rgba(255, 255, 255, 0.08);
       --progress:    oklch(0.72 0.14 155);
+      --brand:       #e07a5a;  /* YuE2 terracotta (#aa482f on the official light site), lifted for dark */
       --text:        rgba(255, 255, 255, 0.87);
       --text-muted:  rgba(255, 255, 255, 0.40);
       --text-faint:  rgba(255, 255, 255, 0.25);
@@ -45,25 +47,26 @@
 
     /* ── Header ───────────────────────────────────────────────────────────── */
     header { padding: 0 0 20px; text-align: left; }
-    /* Wordmark geometry is derived from the logo PNG (1200x224: text rows 65-152, text runs to the
-       right edge) and the reference lockup: divider 1/4 mark-height from the "3" and from "jam",
-       divider = 0.56 mark-height tall, "jam" x-height = 0.75 x "Music 3" cap height, same baseline. */
-    .wordmark { --h: 26px; display: inline-block; line-height: 0; white-space: nowrap; margin-bottom: 6px; }
-    .wordmark-logo {
-      height: var(--h); width: auto; display: inline-block;
-      vertical-align: calc(var(--h) * -0.321);   /* put the PNG's text baseline on the line baseline */
+    /* Lockup after the official YuE2 site: YuE mark + "YuE" in Space Grotesk 600 with a raised accent "2". */
+    .wordmark { --h: 26px; display: inline-flex; align-items: baseline; white-space: nowrap; margin-bottom: 6px; line-height: 1; }
+    .wordmark-mark { width: var(--h); height: var(--h); align-self: center; margin-right: calc(var(--h) * 0.32); }
+    .wordmark-name {
+      font-family: 'Space Grotesk', 'Hanken Grotesk', system-ui, sans-serif; font-weight: 600;
+      font-size: calc(var(--h) * 0.86); letter-spacing: -0.08em; color: var(--text);
+    }
+    .wordmark-name span {
+      display: inline-block; color: var(--brand); font-size: 0.7em; letter-spacing: 0;
+      margin-left: 0.14em; transform: translateY(-0.26em);
     }
     .wordmark-divider {
-      display: inline-block; width: 1px; height: calc(var(--h) * 0.56);
-      background: rgb(148, 148, 149); vertical-align: calc(var(--h) * -0.125);
-      margin-left: calc(var(--h) * 0.25);   /* the PNG has no right padding: the "3" ends at its edge */
-      margin-right: calc(var(--h) * 0.25);
+      display: inline-block; width: 1px; height: calc(var(--h) * 0.56); align-self: center;
+      background: rgb(148, 148, 149); margin: 0 calc(var(--h) * 0.3);
     }
     .wordmark-jam {
-      display: inline-block; font-family: 'Outfit', 'Hanken Grotesk', system-ui, sans-serif;
+      display: inline-block; font-family: 'Space Grotesk', 'Hanken Grotesk', system-ui, sans-serif;
       font-size: calc(var(--h) * 0.62); font-weight: 500; letter-spacing: 0.11em; line-height: 1;
-      vertical-align: baseline; text-decoration: none;
-      background: linear-gradient(90deg, #d42a68 0%, #dd4b5a 50%, #ef7640 100%);
+      text-decoration: none;
+      background: linear-gradient(90deg, #c4573a 0%, #e07a5a 50%, #f2a07c 100%);
       -webkit-background-clip: text; background-clip: text; color: transparent;
       transition: opacity 0.15s;
     }
@@ -344,9 +347,9 @@
 
       <header>
         <div class="wordmark">
-          <img class="wordmark-logo" src="logo.png" alt="MiniMax Music 3" /><span class="wordmark-divider" aria-hidden="true"></span><a href="https://huggingface.co/MiniMaxAI/MiniMax-Music3" target="_blank" class="wordmark-jam">jam</a>
+          <img class="wordmark-mark" src="logo.svg" alt="" /><span class="wordmark-name">YuE<span>2</span></span><span class="wordmark-divider" aria-hidden="true"></span><a href="https://huggingface.co/m-a-p/YuE2-3B" target="_blank" class="wordmark-jam">jam</a>
         </div>
-        <p>Describe any song. An LLM writes it, MiniMax Music 3 sings it.</p>
+        <p>Describe any song. An LLM writes it, YuE2 sings it.</p>
       </header>
 
       <div class="compose-box">
@@ -359,6 +362,7 @@
               <option value="30">30s</option>
               <option value="60" selected>1 min</option>
               <option value="120">2 min</option>
+              <option value="180">3 min</option>
             </select>
           </label>
           <label class="pill"><input type="checkbox" id="instrumental-check" /><span>Instrumental</span></label>
@@ -369,7 +373,7 @@
       </div>
       <p class="upsell" id="upsell-studio">
         Don't forget to
-        <a href="https://huggingface.co/MiniMaxAI/MiniMax-Music3" target="_blank" rel="noopener">like the model <svg class="heart-icon" viewBox="0 0 24 24" fill="#e53935" aria-hidden="true"><path d="M12 21s-7.09-4.35-9.64-8.36C.66 10.02 1.24 6.6 4.1 5.02c2.2-1.22 4.9-.63 6.4 1.18.6.72 1.02 1.55 1.5 1.55s.9-.83 1.5-1.55c1.5-1.81 4.2-2.4 6.4-1.18 2.86 1.58 3.44 5 1.74 7.62C19.09 16.65 12 21 12 21z"/></svg></a>
+        <a href="https://huggingface.co/m-a-p/YuE2-3B" target="_blank" rel="noopener">like the model <svg class="heart-icon" viewBox="0 0 24 24" fill="#e53935" aria-hidden="true"><path d="M12 21s-7.09-4.35-9.64-8.36C.66 10.02 1.24 6.6 4.1 5.02c2.2-1.22 4.9-.63 6.4 1.18.6.72 1.02 1.55 1.5 1.55s.9-.83 1.5-1.55c1.5-1.81 4.2-2.4 6.4-1.18 2.86 1.58 3.44 5 1.74 7.62C19.09 16.65 12 21 12 21z"/></svg></a>
       </p>
       <div class="status-bar" id="status-bar"></div>
 
@@ -405,10 +409,10 @@
   </div>
 
   <footer>
-    Powered by <a href="https://huggingface.co/MiniMaxAI/MiniMax-Music3" target="_blank">MiniMax Music 3</a> ·
-    <a href="https://huggingface.co/spaces/multimodalart/minimax-music3-prompting-guide" target="_blank">Prompting guide</a> ·
-    <a href="https://huggingface.co/spaces/MiniMaxAI/MiniMax-Music3" target="_blank">Official Studio</a> ·
-    <a href="https://huggingface.co/buckets/victor/minimax-music3-community" target="_blank">Community bucket</a>
+    Powered by <a href="https://huggingface.co/m-a-p/YuE2-3B" target="_blank">YuE2-3B</a> (CC BY-NC 4.0) ·
+    <a href="https://map-yue2.github.io/" target="_blank">Project page</a> ·
+    <a href="https://github.com/multimodal-art-projection/YuE" target="_blank">GitHub</a> ·
+    <a href="https://huggingface.co/buckets/Mike0021/yue2-jam-community" target="_blank">Community bucket</a>
   </footer>
 
   <script type="module">
@@ -631,7 +635,7 @@
           ctx.fillText("Create your own song:", W / 2, 880);
           ctx.fillStyle = "rgba(255,255,255,0.55)";
           ctx.font = "500 33px 'Hanken Grotesk', sans-serif";
-          ctx.fillText("hf.co/spaces/victor/MiniMax-Music3-Jam", W / 2, 930);
+          ctx.fillText("hf.co/spaces/Mike0021/YuE2-Jam", W / 2, 930);
           ctx.textAlign = "left";
         }
 
@@ -927,7 +931,7 @@
       ).join("");
       placeholder.innerHTML = `
         <div class="placeholder-title">${esc(desc.slice(0, 80))}</div>
-        <div class="placeholder-sub">Writing lyrics &amp; structured caption…</div>
+        <div class="placeholder-sub">Writing lyrics &amp; style…</div>
         <div class="fake-waveform">${bars}</div>
       `;
       outputSection.parentNode.insertBefore(placeholder, outputSection);
@@ -970,7 +974,7 @@
               // Intermediate progress message
               if (result.title) phTitle.textContent = result.title;
               if (result.status === "generating") {
-                startEta(Number(result.eta) || 60, result.message || "MiniMax Music 3 is recording…");
+                startEta(Number(result.eta) || 60, result.message || "YuE2 is recording…");
               } else {
                 phSub.textContent = result.message || "Working…";
               }

requirements.txt

@@ -1,6 +1,11 @@
-git+https://github.com/huggingface/diffusers@82319140e0456fd58beff0a251c38825bfc310de
+# yue2_infer itself is installed by engine.py with --no-deps from the m-a-p/YuE2-3B repo: its metadata
+# hard-pins huggingface-hub==0.36.2, which conflicts with Gradio 6. These are its real runtime deps.
+torch==2.10.0
 transformers==5.15.0
+diffusers==0.41.0
 accelerate
+safetensors
+tiktoken
 scipy
 spaces
 openai