Add v1.6 + v1.7 model selector (7 selectable generators); sync v1.7-capable inference bundle

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

README.md

@@ -10,6 +10,12 @@ app_file: app.py
 pinned: false
 license: mit
 models:
+  - JacobLinCool/softchart-v17
+  - JacobLinCool/softchart-v17-small
+  - JacobLinCool/softchart-v17-tiny
+  - JacobLinCool/softchart-v16
+  - JacobLinCool/softchart-v16-small
+  - JacobLinCool/softchart-v16-tiny
   - JacobLinCool/softchart-v15
   - JacobLinCool/softchart-planner
 ---

app.py

@@ -33,30 +33,52 @@ from softchart.vocab import FPS, HOP, N_FFT, N_MELS, SR
 LOGGER = logging.getLogger("softchart.space")
 STATIC_DIR = Path(__file__).with_name("static")
 
-V15_REPO = os.environ.get("SC_V15", "JacobLinCool/softchart-v15")
 PLAN_REPO = os.environ.get("SC_PLAN", "JacobLinCool/softchart-planner")
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 
+# Selectable generators: three generations x three sizes (plus the v1.5 single
+# model). All are dual (slot + time), beat- and plan-conditioned, MIT licensed.
+# https://huggingface.co/collections/JacobLinCool/softchart-generators
+MODELS = {
+    "v1.7": "JacobLinCool/softchart-v17",
+    "v1.7-small": "JacobLinCool/softchart-v17-small",
+    "v1.7-tiny": "JacobLinCool/softchart-v17-tiny",
+    "v1.6": "JacobLinCool/softchart-v16",
+    "v1.6-small": "JacobLinCool/softchart-v16-small",
+    "v1.6-tiny": "JacobLinCool/softchart-v16-tiny",
+    "v1.5": "JacobLinCool/softchart-v15",
+}
+DEFAULT_MODEL = os.environ.get("SC_MODEL", "v1.7")
+
 COURSE_DENS = {"easy": 1, "normal": 2, "hard": 4, "oni": 7}
 CHAR = {"don": "1", "ka": "2", "don_big": "3", "ka_big": "4",
         "roll": "5", "roll_big": "6", "balloon": "7"}
 SUB = 96
 
-_MODELS = {}
+_MODELS = {}  # repo id -> {"gen","slot","beat"}, loaded lazily and cached
+_PLANNER = {}  # the planner is model-agnostic and shared across generators
 
 
-def get_models(*, include_planner=False):
-    if "gen" not in _MODELS:
-        u = load_hf(V15_REPO, device=DEVICE)
+def get_models(model_choice=DEFAULT_MODEL, *, include_planner=False):
+    repo = MODELS.get(model_choice)
+    if repo is None:
+        raise ValueError(
+            f"unknown model {model_choice!r}; choose one of {list(MODELS)}"
+        )
+    if repo not in _MODELS:
+        u = load_hf(repo, device=DEVICE)
         if (not getattr(u, "_dual", False) or u.beat is None
                 or not getattr(u, "_has_plan", False)):
             raise RuntimeError(
-                f"{V15_REPO} must provide dual generation, beat, and plan conditioning"
+                f"{repo} must provide dual generation, beat, and plan conditioning"
             )
-        _MODELS.update(gen=u, slot=u, beat=u)
-    if include_planner and "plan" not in _MODELS:
-        _MODELS["plan"] = SoftChartPlanner.from_pretrained(PLAN_REPO).to(DEVICE).eval()
-    return _MODELS
+        _MODELS[repo] = {"gen": u, "slot": u, "beat": u}
+    models = dict(_MODELS[repo])
+    if include_planner:
+        if "plan" not in _PLANNER:
+            _PLANNER["plan"] = SoftChartPlanner.from_pretrained(PLAN_REPO).to(DEVICE).eval()
+        models["plan"] = _PLANNER["plan"]
+    return models
 
 
 def load_logmel(path):
@@ -356,6 +378,7 @@ def generate_chart(
     temperature: float,
     top_p: float,
     drum_volume: float,
+    model_choice: str = DEFAULT_MODEL,
 ) -> dict[str, object]:
     """Stream the actual inference stages to the custom frontend."""
     workdir = tempfile.mkdtemp(prefix="softchart-request-")
@@ -368,11 +391,15 @@ def generate_chart(
         top_p = float(top_p)
         drum_volume = float(drum_volume)
 
+        if model_choice not in MODELS:
+            raise ValueError(
+                f"Unknown model {model_choice!r}. Choose one of: {', '.join(MODELS)}."
+            )
         yield _progress(
             "loading", 0.03, "Preparing",
-            "Loading SoftChart.",
+            f"Loading SoftChart {model_choice}.",
         )
-        models = get_models(include_planner=use_planner)
+        models = get_models(model_choice, include_planner=use_planner)
 
         yield _progress(
             "audio", 0.11, "Listening",

softchart/generate.py

@@ -24,12 +24,11 @@ def _dev_type(device):
 
 
 def _autocast(device):
-    """bf16 autocast on CUDA/MPS; CPU runs fp32."""
+    """bf16 autocast on CUDA; no-op elsewhere (MPS/CPU run fp32)."""
     import contextlib
 
-    dev = _dev_type(device)
-    if dev in {"cuda", "mps"}:
-        return torch.autocast(dev, dtype=torch.bfloat16)
+    if _dev_type(device) == "cuda":
+        return torch.autocast("cuda", dtype=torch.bfloat16)
     return contextlib.nullcontext()
 CTX_LEN = 12  # fixed-length previous-window context (note-type tokens)
 MIN_GAP_FRAMES = 4  # ~46 ms minimum inter-note gap enforced during decoding
@@ -42,24 +41,38 @@ SPAN_MAX = {"roll": 3.5, "roll_big": 4.0, "balloon": 6.5}
 def load_model(ckpt_path, device="cuda"):
     ck = torch.load(ckpt_path, map_location=device)
     sd = ck["model"]
-    a = ck.get("args")
-    if not isinstance(a, dict) or not a:
-        raise ValueError(
-            f"{ckpt_path} is missing checkpoint args; refusing to infer model "
-            "capabilities from weight shapes."
-        )
     vocab_size = sd["tok_emb.weight"].shape[0]
     aux = any(k.startswith("aux") for k in sd)
     gctx = any(k.startswith("gsum_proj") for k in sd)
-    in_ch = sd["frontend.0.weight"].shape[1]  # slot models carry +2 phase channels
+    a = ck.get("args", {}) or {}
+    front_ch = sd["frontend.0.weight"].shape[1]  # 128 (clean) or 130 (legacy slot)
     emb_w = sd["tok_emb.weight"].shape[1]
     d_model = a.get("d_model", 512)
+    # clean_phase (v1.6): encoder frontend is 128ch and a phase_proj is present.
+    clean_phase = bool(a.get("clean_phase", False)) or ("phase_proj.0.weight" in sd)
+    # legacy slot models fed phase to the encoder (in_ch=130); clean models keep
+    # in_ch=130 at the data level but only 128 reach the frontend.
+    in_ch = 130 if (clean_phase or front_ch == 130) else front_ch
+    # v1.7 arch flags: prefer saved args; fall back to state-dict keys so
+    # args-less checkpoints of the new arch still load
+    adapter_rank_ffn = int(a.get("adapter_rank_ffn", 0) or 0)
+    if not adapter_rank_ffn and "decoder.ffn_adapters.0.down.weight" in sd:
+        adapter_rank_ffn = sd["decoder.ffn_adapters.0.down.weight"].shape[0]
+    depth_emb = bool(a.get("depth_emb", False)) or ("decoder.depth_emb" in sd)
     model = ChartModel(
-        d_model=d_model, enc_layers=a.get("enc_layers", 6),
+        d_model=d_model, nhead=a.get("nhead", 8),
+        enc_layers=a.get("enc_layers", 6),
         dec_layers=a.get("dec_layers", 6), ffn=a.get("ffn", 2048),
         vocab_size=vocab_size, aux=aux, global_ctx=gctx,
         func_time=a.get("func_time", False), in_ch=in_ch,
         emb_factor=emb_w if emb_w != d_model else None,
+        clean_phase=clean_phase,
+        enc_share=a.get("enc_share") or None,
+        dec_share=a.get("dec_share") or None,
+        adapter_rank=int(a.get("adapter_rank", 0) or 0),
+        unique_layernorm=bool(a.get("unique_layernorm", False)),
+        adapter_rank_ffn=adapter_rank_ffn, depth_emb=depth_emb,
+        unshare_last_dec=bool(a.get("unshare_last_dec", False)),
     ).to(device)
     if any(k.startswith("ptr") for k in sd):
         model.enable_ptr()
@@ -68,13 +81,24 @@ def load_model(ckpt_path, device="cuda"):
     model.to(device)  # newly enabled heads default to CPU
     model.load_state_dict(sd)
     model.eval()
-    model._has_ctx = bool(a.get("ctx", False))
-    model._has_sib = bool(a.get("sibling", False))
-    model._has_style = bool(a.get("style", False))
-    model._has_sync = bool(a.get("sync_token", False))
-    model._has_plan = bool(a.get("plan", False))
-    model._dual = bool(a.get("dual", False))
-    model._slot = bool(a.get("slot", False)) or model._dual
+    # capability detection: prefer explicit training args (vocab-size inference
+    # wrongly added prefix slots to models that never trained with them)
+    if a:
+        model._has_ctx = bool(a.get("ctx", False))
+        model._has_sib = bool(a.get("sibling", False))
+        model._has_style = bool(a.get("style", False))
+        model._has_sync = bool(a.get("sync_token", False))
+        model._has_plan = bool(a.get("plan", False))
+        model._dual = bool(a.get("dual", False))
+        model._slot = bool(a.get("slot", False)) or model._dual
+    else:  # legacy fallback
+        model._has_ctx = vocab_size > VOCAB.sep
+        model._has_sib = vocab_size > VOCAB.sib
+        model._has_style = False
+        model._has_sync = False
+        model._has_plan = False
+        model._slot = False
+        model._dual = False
     model._has_gctx = gctx
     return model
 
@@ -156,12 +180,16 @@ def decode_windows(model, mels, prefixes, device="cuda", temperature=1.0, top_p=
     gen_device = "cpu" if _dev_type(device) == "mps" else device
     gen = torch.Generator(device=gen_device)
     gen.manual_seed(seed)
+    mels_dev = mels.to(device)
     with _autocast(device):
         memory = model.encode(
-            mels.to(device),
+            mels_dev,
             gsum=gsum.to(device) if gsum is not None else None,
             pos_bucket=pos_buckets.to(device) if pos_buckets is not None else None,
         )
+        # clean_phase (v1.6): inject the grid-phase channels into the memory the
+        # DECODER reads. No-op for legacy models (in_ch already carried phase).
+        memory = model.phase_mem(memory, mels_dev)
 
     seqs = torch.tensor(prefixes, dtype=torch.long, device=device)
     if use_cfg:  # rows B..2B: same ctx, conditions replaced by UNK
@@ -177,20 +205,10 @@ def decode_windows(model, mels, prefixes, device="cuda", temperature=1.0, top_p=
     # lattice state: previous inter-onset interval (frames); -1 = unknown
     prev_ioi = torch.full((B,), -1, dtype=torch.long, device=device)
     ratios = torch.tensor(LATTICE_RATIOS, device=device)
-    time_pos = torch.arange(WINDOW, device=device).unsqueeze(0)
-
-    if model.training or not hasattr(model, "init_decode_cache"):
-        raise RuntimeError("decode_windows requires an eval model with SDPA/KV-cache decoding")
 
-    with _autocast(device):
-        cache = model.init_decode_cache(memory, max_len=MAX_TGT)
-        logits_all = None
-        for p in range(plen):
-            logits_all = model.decode_cached_step(seqs[:, p], cache).float()
-
-    gen_toks = torch.full((B, MAX_TGT - plen), v.pad, dtype=torch.long, device=device)
-    n_steps = 0
-    for step in range(MAX_TGT - plen):
+    for _ in range(MAX_TGT - plen):
+        with _autocast(device):
+            logits_all = model.decode(seqs, memory)[:, -1].float()
         if use_cfg:
             logits = logits_all[B:] + cfg_w * (logits_all[:B] - logits_all[B:])
         else:
@@ -202,6 +220,7 @@ def decode_windows(model, mels, prefixes, device="cuda", temperature=1.0, top_p=
         mask[expect_note] = note_row
         idx = (~expect_note).nonzero(as_tuple=True)[0]
         if len(idx):
+            time_pos = torch.arange(WINDOW, device=device).unsqueeze(0)
             sub = torch.full((len(idx), logits.shape[1]), float("-inf"), device=device)
             sub[:, v.eos] = 0.0
             ok = time_pos >= (last_time[idx] + min_gap).unsqueeze(1)
@@ -245,9 +264,8 @@ def decode_windows(model, mels, prefixes, device="cuda", temperature=1.0, top_p=
             nxt = si[torch.arange(B, device=device), pick]
 
         nxt = torch.where(done, torch.full_like(nxt, v.pad), nxt)
-        gen_toks[:, step] = nxt
-        n_steps = step + 1
         step_tok = torch.cat([nxt, nxt], dim=0) if use_cfg else nxt
+        seqs = torch.cat([seqs, step_tok.unsqueeze(1)], dim=1)
         is_time = (nxt >= v.time0) & (nxt < v.time0 + WINDOW)
         new_time = nxt - v.time0
         upd = is_time & (last_time >= 0)
@@ -257,12 +275,10 @@ def decode_windows(model, mels, prefixes, device="cuda", temperature=1.0, top_p=
         done = done | (nxt == v.eos)
         if done.all():
             break
-        with _autocast(device):
-            logits_all = model.decode_cached_step(step_tok, cache).float()
 
     out = []
     for b in range(B):
-        toks = gen_toks[b, :n_steps].tolist()
+        toks = seqs[b, plen:].tolist()
         events = []
         cur_t = None
         for t in toks:

softchart/hf.py

@@ -32,12 +32,24 @@ class SoftChartGenerator(
     def __init__(self, d_model=256, enc_layers=4, dec_layers=4, ffn=1024,
                  vocab_size=1802, aux=True, global_ctx=False, func_time=False,
                  ptr=False, beat=False, in_ch=None, emb_factor=None,
-                 capabilities=None):
+                 capabilities=None, nhead=8, clean_phase=False,
+                 enc_share=None, dec_share=None, adapter_rank=0,
+                 unique_layernorm=False, adapter_rank_ffn=0, depth_emb=False,
+                 unshare_last_dec=False):
         super().__init__()
+        # nhead and the v1.6/v1.7 sharing flags (enc_share/dec_share/adapter_rank/
+        # unique_layernorm/adapter_rank_ffn/depth_emb/unshare_last_dec) and
+        # clean_phase must be persisted in config.json: from_pretrained rebuilds
+        # the architecture from these kwargs alone, before any weights are loaded.
+        # Defaults reproduce the pre-v1.6 unshared architecture for older repos.
         self.net = ChartModel(
-            d_model=d_model, enc_layers=enc_layers, dec_layers=dec_layers, ffn=ffn,
-            vocab_size=vocab_size, aux=aux, global_ctx=global_ctx, func_time=func_time,
-            ptr=ptr, beat=beat, in_ch=in_ch, emb_factor=emb_factor,
+            d_model=d_model, nhead=nhead, enc_layers=enc_layers, dec_layers=dec_layers,
+            ffn=ffn, vocab_size=vocab_size, aux=aux, global_ctx=global_ctx,
+            func_time=func_time, ptr=ptr, beat=beat, in_ch=in_ch, emb_factor=emb_factor,
+            clean_phase=clean_phase, enc_share=enc_share, dec_share=dec_share,
+            adapter_rank=adapter_rank, unique_layernorm=unique_layernorm,
+            adapter_rank_ffn=adapter_rank_ffn, depth_emb=depth_emb,
+            unshare_last_dec=unshare_last_dec,
         )
         # capabilities: which condition axes this checkpoint was trained with,
         # so inference knows which prefix tokens to emit

softchart/model.py

@@ -4,7 +4,6 @@ import math
 
 import torch
 import torch.nn as nn
-import torch.nn.functional as F
 
 from .vocab import N_MELS, VOCAB, WINDOW
 
@@ -34,6 +33,164 @@ class BeatHiRes(nn.Module):
         return self.out(h).transpose(1, 2)
 
 
+def _parse_pattern(spec, n):
+    """Layer-sharing schedule. spec is either an int (number of UNIQUE
+    physical layers, cycled to length n) or a comma string like "E0,E1,E0,E1"
+    (labels; each distinct label is one physical layer). Returns a list of n
+    physical-layer indices, e.g. [0,1,0,1] for 2-unique/4-physical-depth."""
+    if spec is None:
+        return list(range(n))  # no sharing: every layer unique
+    if isinstance(spec, int):
+        return [k % spec for k in range(n)]
+    labels = [s.strip() for s in str(spec).split(",") if s.strip()]
+    assert len(labels) == n, f"pattern {spec} has {len(labels)} labels, need {n}"
+    order = {}
+    out = []
+    for lb in labels:
+        if lb not in order:
+            order[lb] = len(order)
+        out.append(order[lb])
+    return out
+
+
+class Adapter(nn.Module):
+    """Rank-r residual adapter applied after a (possibly reused) transformer
+    block: x + gate * up(gelu(down(x))). gate init 0 so the whole stack starts
+    identical to hard weight sharing; the adapter only differentiates a reused
+    physical layer as training moves the gate off zero."""
+
+    def __init__(self, d, rank):
+        super().__init__()
+        self.down = nn.Linear(d, rank, bias=False)
+        self.up = nn.Linear(rank, d, bias=False)
+        nn.init.normal_(self.down.weight, std=0.02)
+        nn.init.zeros_(self.up.weight)
+        self.gate = nn.Parameter(torch.zeros(1))
+
+    def forward(self, x):
+        return x + self.gate * self.up(nn.functional.gelu(self.down(x)))
+
+
+class SharedEncoder(nn.Module):
+    """Encoder whose physical layers are reused according to a sharing pattern.
+    Each POSITION in the depth keeps its own (a) rank-r adapter and (b) final
+    LayerNorm — so ΔW starts at 0 (hard sharing) but every position can drift.
+    With pattern=None this is exactly n unique layers + a norm, matching the
+    stock nn.TransformerEncoder param count (adapters/pos-norms are opt-in).
+
+    v1.7 depth-diversity options (all default-off, init == v1.6 behaviour):
+      depth_emb: per-depth learned d-vector ADDED to the block input at each
+        reuse (params = depth x d, zero-init so init == hard sharing).
+      adapter_rank_ffn > 0: SPLIT adapters — instead of one post-block adapter,
+        each depth owns a rank-`adapter_rank` adapter on the attention sublayer
+        output and a rank-`adapter_rank_ffn` adapter on the FFN sublayer output
+        (patterning lives in the FFN). Gate init 0 keeps init == hard sharing.
+    """
+
+    def __init__(self, d, nhead, ffn, dropout, pattern, adapter_rank=0,
+                 unique_layernorm=False, adapter_rank_ffn=0, depth_emb=False):
+        super().__init__()
+        # `pattern` is the resolved list of physical-layer indices per depth
+        n_phys = max(pattern) + 1
+        self.layers = nn.ModuleList([
+            nn.TransformerEncoderLayer(d, nhead, ffn, dropout, activation="gelu",
+                                       batch_first=True, norm_first=True)
+            for _ in range(n_phys)])
+        self.plan = pattern
+        self.split = adapter_rank_ffn > 0
+        if self.split:  # v1.7: per-sublayer adapters (attention rank-a, FFN rank-f)
+            self.attn_adapters = nn.ModuleList([
+                Adapter(d, adapter_rank) if adapter_rank else nn.Identity()
+                for _ in pattern])
+            self.ffn_adapters = nn.ModuleList([
+                Adapter(d, adapter_rank_ffn) for _ in pattern])
+        else:  # v1.6: one residual adapter after the whole block
+            self.adapters = nn.ModuleList([
+                Adapter(d, adapter_rank) if adapter_rank else nn.Identity()
+                for _ in pattern])
+        self.depth_emb = (nn.Parameter(torch.zeros(len(pattern), d))
+                          if depth_emb else None)
+        self.pos_norms = nn.ModuleList([
+            nn.LayerNorm(d) if unique_layernorm else nn.Identity()
+            for _ in pattern])
+        self.norm = nn.LayerNorm(d)
+
+    def forward(self, x, src_key_padding_mask=None):
+        for k, phys in enumerate(self.plan):
+            if self.depth_emb is not None:
+                x = x + self.depth_emb[k]
+            layer = self.layers[phys]
+            if self.split:
+                # norm_first decomposition of nn.TransformerEncoderLayer with
+                # per-depth adapters applied to each sublayer OUTPUT (Houlsby
+                # placement); at gate=0 this is bit-equal to the stock layer
+                x = x + self.attn_adapters[k](
+                    layer._sa_block(layer.norm1(x), None, src_key_padding_mask))
+                x = x + self.ffn_adapters[k](layer._ff_block(layer.norm2(x)))
+            else:
+                x = layer(x, src_key_padding_mask=src_key_padding_mask)
+                x = self.adapters[k](x)
+            x = self.pos_norms[k](x)
+        return self.norm(x)
+
+
+class SharedDecoder(nn.Module):
+    """Decoder counterpart of SharedEncoder (see that docstring). Split mode
+    puts rank-`adapter_rank` adapters on BOTH attention sublayers (self and
+    cross) and rank-`adapter_rank_ffn` on the FFN sublayer."""
+
+    def __init__(self, d, nhead, ffn, dropout, pattern, adapter_rank=0,
+                 unique_layernorm=False, adapter_rank_ffn=0, depth_emb=False):
+        super().__init__()
+        n_phys = max(pattern) + 1
+        self.layers = nn.ModuleList([
+            nn.TransformerDecoderLayer(d, nhead, ffn, dropout, activation="gelu",
+                                       batch_first=True, norm_first=True)
+            for _ in range(n_phys)])
+        self.plan = pattern
+        self.split = adapter_rank_ffn > 0
+        if self.split:
+            self.sa_adapters = nn.ModuleList([
+                Adapter(d, adapter_rank) if adapter_rank else nn.Identity()
+                for _ in pattern])
+            self.ca_adapters = nn.ModuleList([
+                Adapter(d, adapter_rank) if adapter_rank else nn.Identity()
+                for _ in pattern])
+            self.ffn_adapters = nn.ModuleList([
+                Adapter(d, adapter_rank_ffn) for _ in pattern])
+        else:
+            self.adapters = nn.ModuleList([
+                Adapter(d, adapter_rank) if adapter_rank else nn.Identity()
+                for _ in pattern])
+        self.depth_emb = (nn.Parameter(torch.zeros(len(pattern), d))
+                          if depth_emb else None)
+        self.pos_norms = nn.ModuleList([
+            nn.LayerNorm(d) if unique_layernorm else nn.Identity()
+            for _ in pattern])
+        self.norm = nn.LayerNorm(d)
+
+    def forward(self, tgt, memory, tgt_mask=None, tgt_key_padding_mask=None,
+                tgt_is_causal=False):
+        x = tgt
+        for k, phys in enumerate(self.plan):
+            if self.depth_emb is not None:
+                x = x + self.depth_emb[k]
+            layer = self.layers[phys]
+            if self.split:
+                x = x + self.sa_adapters[k](layer._sa_block(
+                    layer.norm1(x), tgt_mask, tgt_key_padding_mask, tgt_is_causal))
+                x = x + self.ca_adapters[k](layer._mha_block(
+                    layer.norm2(x), memory, None, None))
+                x = x + self.ffn_adapters[k](layer._ff_block(layer.norm3(x)))
+            else:
+                x = layer(x, memory, tgt_mask=tgt_mask,
+                          tgt_key_padding_mask=tgt_key_padding_mask,
+                          tgt_is_causal=tgt_is_causal)
+                x = self.adapters[k](x)
+            x = self.pos_norms[k](x)
+        return self.norm(x)
+
+
 class ChartModel(nn.Module):
     def __init__(
         self,
@@ -52,6 +209,14 @@ class ChartModel(nn.Module):
         beat=False,
         in_ch=None,
         emb_factor=None,
+        clean_phase=False,
+        enc_share=None,
+        dec_share=None,
+        adapter_rank=0,
+        unique_layernorm=False,
+        adapter_rank_ffn=0,
+        depth_emb=False,
+        unshare_last_dec=False,
     ):
         super().__init__()
         from .vocab import MAX_TGT
@@ -59,11 +224,17 @@ class ChartModel(nn.Module):
         vocab_size = vocab_size or VOCAB.size
         max_tgt = max_tgt or MAX_TGT
         self.d_model = d_model
-        self.in_ch = in_ch or N_MELS  # slot mode appends 2 grid-phase channels
-
-        # conv frontend: (B, in_ch, T) -> (B, T/4, d)
+        # clean_phase (v1.6): the encoder never sees the 2 grid-phase channels
+        # (in_ch stays N_MELS), and phase is injected into the DECODER memory
+        # only, via a small projection. This removes the condition leak that
+        # forced beat supervision to be masked on slot windows in v1.5.
+        self.clean_phase = clean_phase
+        self.in_ch = in_ch or N_MELS  # legacy slot mode appends 2 grid-phase channels
+        front_ch = N_MELS if clean_phase else self.in_ch
+
+        # conv frontend: (B, front_ch, T) -> (B, T/4, d)
         self.frontend = nn.Sequential(
-            nn.Conv1d(self.in_ch, d_model, 3, stride=2, padding=1),
+            nn.Conv1d(front_ch, d_model, 3, stride=2, padding=1),
             nn.GELU(),
             nn.Conv1d(d_model, d_model, 3, stride=2, padding=1),
             nn.GELU(),
@@ -72,14 +243,51 @@ class ChartModel(nn.Module):
         self.register_buffer("enc_pos", sinusoidal(enc_len, d_model), persistent=False)
         self.register_buffer("dec_pos", sinusoidal(max_tgt, d_model), persistent=False)
 
-        enc_layer = nn.TransformerEncoderLayer(
-            d_model, nhead, ffn, dropout, activation="gelu", batch_first=True, norm_first=True
-        )
-        self.encoder = nn.TransformerEncoder(enc_layer, enc_layers, nn.LayerNorm(d_model))
-        dec_layer = nn.TransformerDecoderLayer(
-            d_model, nhead, ffn, dropout, activation="gelu", batch_first=True, norm_first=True
-        )
-        self.decoder = nn.TransformerDecoder(dec_layer, dec_layers, nn.LayerNorm(d_model))
+        # phase injection (clean_phase only): 2 grid-phase channels at frame
+        # rate -> encoder rate (T/4) -> additive conditioning on the memory the
+        # DECODER reads. The beat head reads the pre-injection (clean) memory.
+        # phase_proj input = [measure_phase, beat_phase, valid_flag]. valid=0 on
+        # time-mode windows (their raw phase is -1), giving the decoder a clean
+        # zero-phase conditioning there; slot windows pass valid=1 + real phase.
+        if clean_phase:
+            self.phase_proj = nn.Sequential(
+                nn.Conv1d(3, d_model, 3, stride=2, padding=1),
+                nn.GELU(),
+                nn.Conv1d(d_model, d_model, 3, stride=2, padding=1),
+            )
+        else:
+            self.phase_proj = None
+
+        # sharing schedule (v1.6-small/tiny): reuse physical layers per pattern.
+        # enc_share/dec_share: int (#unique layers) or "E0,E1,E0,E1" label string.
+        self.enc_share = enc_share
+        self.dec_share = dec_share
+        if (enc_share is None and dec_share is None and not adapter_rank
+                and not adapter_rank_ffn and not depth_emb and not unshare_last_dec):
+            enc_layer = nn.TransformerEncoderLayer(
+                d_model, nhead, ffn, dropout, activation="gelu",
+                batch_first=True, norm_first=True)
+            self.encoder = nn.TransformerEncoder(enc_layer, enc_layers,
+                                                 nn.LayerNorm(d_model))
+            dec_layer = nn.TransformerDecoderLayer(
+                d_model, nhead, ffn, dropout, activation="gelu",
+                batch_first=True, norm_first=True)
+            self.decoder = nn.TransformerDecoder(dec_layer, dec_layers,
+                                                 nn.LayerNorm(d_model))
+        else:
+            enc_plan = _parse_pattern(enc_share, enc_layers)
+            dec_plan = _parse_pattern(dec_share, dec_layers)
+            # v1.7: un-share the LAST decoder layer (pattern-shaping layer in
+            # front of the generation head gets its own physical parameters);
+            # no-op if that depth is already unique.
+            if unshare_last_dec and dec_plan.count(dec_plan[-1]) > 1:
+                dec_plan = dec_plan[:-1] + [max(dec_plan) + 1]
+            self.encoder = SharedEncoder(d_model, nhead, ffn, dropout, enc_plan,
+                                         adapter_rank, unique_layernorm,
+                                         adapter_rank_ffn, depth_emb)
+            self.decoder = SharedDecoder(d_model, nhead, ffn, dropout, dec_plan,
+                                         adapter_rank, unique_layernorm,
+                                         adapter_rank_ffn, depth_emb)
 
         # ALBERT-style factorized embeddings (v1.5): vocab->E->d. Position
         # tokens dominate the table (1728/1810 rows), so E=64 cuts the
@@ -132,9 +340,13 @@ class ChartModel(nn.Module):
             self.time_proj = None
 
     def encode(self, mel, gsum=None, pos_bucket=None):
-        # mel: (B, n_mels, T); gsum: (B, G, n_mels) whole-song summary chunks;
-        # pos_bucket: (B,) window-position bucket in [0, 16)
-        h = self.frontend(mel).transpose(1, 2)  # (B, T/4, d)
+        # mel: (B, C, T). clean_phase: C may be N_MELS (audio only) or N_MELS+2
+        # (audio + 2 grid-phase channels); only the audio channels reach the
+        # encoder, so the returned memory is CLEAN (phase-free) and safe for the
+        # beat head. gsum: (B, G, n_mels) whole-song summary chunks;
+        # pos_bucket: (B,) window-position bucket in [0, 16).
+        audio = mel[:, :N_MELS] if self.clean_phase else mel
+        h = self.frontend(audio).transpose(1, 2)  # (B, T/4, d)
         h = h + self.enc_pos[: h.shape[1]]
         if self.gsum_proj is not None and gsum is not None:
             g = self.gsum_proj(gsum) + self.seg_emb[1] + self.gpos[: gsum.shape[1]]
@@ -143,6 +355,24 @@ class ChartModel(nn.Module):
             h = torch.cat([p, g, h], dim=1)
         return self.encoder(self.dropout(h))
 
+    def phase_mem(self, memory, mel):
+        """Phase-conditioned copy of `memory` for the DECODER to cross-attend.
+        Adds a projection of the grid-phase channels to the audio-frame slice
+        of memory; the beat head keeps reading the clean `memory`. No-op unless
+        clean_phase is on and phase channels are present. Time-mode windows
+        (raw phase = -1) get valid=0 and zeroed phase -> ~zero conditioning."""
+        nch = N_MELS
+        if not self.clean_phase or mel.shape[1] < nch + 2:
+            return memory
+        ph = mel[:, nch:nch + 2]  # (B, 2, T) in [0,1); -1 marks no-grid frames
+        valid = (ph[:, :1] >= 0).float()  # 1 where a grid exists, else 0
+        ph_in = torch.cat([ph.clamp(min=0.0), valid], dim=1)  # (B, 3, T)
+        p = self.phase_proj(ph_in).transpose(1, 2)  # (B, T/4, d)
+        L = p.shape[1]
+        out = memory.clone()
+        out[:, -L:] = out[:, -L:] + p  # audio frames are the last L memory slots
+        return out
+
     def emb_matrix(self):
         """Full embedding matrix; factorized and/or functional rows resolved."""
         E = self.tok_emb.weight
@@ -153,146 +383,6 @@ class ChartModel(nn.Module):
             E = torch.cat([E[: VOCAB.time0], t, E[VOCAB.time0 + WINDOW :]], dim=0)
         return E
 
-    @staticmethod
-    def _check_mha_supported(mha):
-        if not getattr(mha, "_qkv_same_embed_dim", True):
-            raise NotImplementedError("cached decode requires same q/k/v embed dims")
-        if getattr(mha, "bias_k", None) is not None or getattr(mha, "bias_v", None) is not None:
-            raise NotImplementedError("cached decode does not support bias_k/bias_v")
-        if getattr(mha, "add_zero_attn", False):
-            raise NotImplementedError("cached decode does not support add_zero_attn")
-
-    @staticmethod
-    def _split_heads(x, mha):
-        B, L, D = x.shape
-        H = mha.num_heads
-        return x.view(B, L, H, D // H).transpose(1, 2).contiguous()
-
-    @staticmethod
-    def _merge_heads(x):
-        B, H, L, Dh = x.shape
-        return x.transpose(1, 2).contiguous().view(B, L, H * Dh)
-
-    @staticmethod
-    def _in_proj_qkv(mha, x):
-        ChartModel._check_mha_supported(mha)
-        D = mha.embed_dim
-        w = mha.in_proj_weight
-        b = mha.in_proj_bias
-        q = F.linear(x, w[:D], b[:D] if b is not None else None)
-        k = F.linear(x, w[D:2 * D], b[D:2 * D] if b is not None else None)
-        v = F.linear(x, w[2 * D:], b[2 * D:] if b is not None else None)
-        return q, k, v
-
-    @staticmethod
-    def _in_proj_q(mha, x):
-        ChartModel._check_mha_supported(mha)
-        D = mha.embed_dim
-        b = mha.in_proj_bias
-        return F.linear(x, mha.in_proj_weight[:D], b[:D] if b is not None else None)
-
-    @staticmethod
-    def _in_proj_kv(mha, x):
-        ChartModel._check_mha_supported(mha)
-        D = mha.embed_dim
-        w = mha.in_proj_weight
-        b = mha.in_proj_bias
-        k = F.linear(x, w[D:2 * D], b[D:2 * D] if b is not None else None)
-        v = F.linear(x, w[2 * D:], b[2 * D:] if b is not None else None)
-        return ChartModel._split_heads(k, mha), ChartModel._split_heads(v, mha)
-
-    @staticmethod
-    def _sdpa(mha, q, k, v, dropout_p=0.0):
-        q = ChartModel._split_heads(q, mha)
-        y = F.scaled_dot_product_attention(
-            q, k, v, dropout_p=dropout_p, is_causal=False)
-        y = ChartModel._merge_heads(y)
-        return mha.out_proj(y)
-
-    def init_decode_cache(self, memory, max_len=None):
-        """Prepare an inference-only KV cache for decode_cached_step().
-
-        This adds no parameters or buffers: all projections read the existing
-        nn.TransformerDecoderLayer weights.
-        Cross-attention K/V are static for a window, so they are projected once.
-        Self-attention K/V are preallocated lazily on the first generated token.
-        """
-        max_len = max_len or self.dec_pos.shape[0]
-        layers = []
-        for layer in self.decoder.layers:
-            mem_k, mem_v = self._in_proj_kv(layer.multihead_attn, memory)
-            layers.append({
-                "self_k": None,
-                "self_v": None,
-                "mem_k": mem_k,
-                "mem_v": mem_v,
-            })
-        return {
-            "layers": layers,
-            "pos": 0,
-            "max_len": int(max_len),
-            "E": self.emb_matrix(),
-        }
-
-    def _cached_sa_block(self, layer, x, cache_layer, pos):
-        q, k, v = self._in_proj_qkv(layer.self_attn, x)
-        k = self._split_heads(k, layer.self_attn)
-        v = self._split_heads(v, layer.self_attn)
-        if cache_layer["self_k"] is None:
-            B, H, _, Dh = k.shape
-            shape = (B, H, cache_layer["max_len"], Dh)
-            cache_layer["self_k"] = k.new_empty(shape)
-            cache_layer["self_v"] = v.new_empty(shape)
-        cache_layer["self_k"][:, :, pos:pos + 1] = k
-        cache_layer["self_v"][:, :, pos:pos + 1] = v
-        k_all = cache_layer["self_k"][:, :, :pos + 1]
-        v_all = cache_layer["self_v"][:, :, :pos + 1]
-        p = layer.self_attn.dropout if self.training else 0.0
-        y = self._sdpa(layer.self_attn, q, k_all, v_all, dropout_p=p)
-        return layer.dropout1(y)
-
-    def _cached_mha_block(self, layer, x, cache_layer):
-        q = self._in_proj_q(layer.multihead_attn, x)
-        p = layer.multihead_attn.dropout if self.training else 0.0
-        y = self._sdpa(
-            layer.multihead_attn, q, cache_layer["mem_k"], cache_layer["mem_v"],
-            dropout_p=p,
-        )
-        return layer.dropout2(y)
-
-    @staticmethod
-    def _ff_block(layer, x):
-        return layer.dropout3(layer.linear2(layer.dropout(layer.activation(layer.linear1(x)))))
-
-    def decode_cached_step(self, token, cache):
-        """Incremental decoder step using SDPA and KV cache.
-
-        token: (B,) or (B, 1) token ids for the current position. Returns
-        next-token logits for that position, matching decode(... )[:, -1] in
-        eval mode up to backend floating-point noise.
-        """
-        if token.dim() == 1:
-            token = token[:, None]
-        pos = int(cache["pos"])
-        if pos >= cache["max_len"] or pos >= self.dec_pos.shape[0]:
-            raise RuntimeError("decoder cache exceeded configured max length")
-        E = cache["E"]
-        h = F.embedding(token, E) * math.sqrt(self.d_model) + self.dec_pos[pos:pos + 1]
-        for layer, lc in zip(self.decoder.layers, cache["layers"]):
-            lc["max_len"] = cache["max_len"]
-            if layer.norm_first:
-                h = h + self._cached_sa_block(layer, layer.norm1(h), lc, pos)
-                h = h + self._cached_mha_block(layer, layer.norm2(h), lc)
-                h = h + self._ff_block(layer, layer.norm3(h))
-            else:
-                h = layer.norm1(h + self._cached_sa_block(layer, h, lc, pos))
-                h = layer.norm2(h + self._cached_mha_block(layer, h, lc))
-                h = layer.norm3(h + self._ff_block(layer, h))
-        if self.decoder.norm is not None:
-            h = self.decoder.norm(h)
-        cache["pos"] = pos + 1
-        return (h @ E.T).squeeze(1)
-
     def decode(self, tgt_in, memory):
         # tgt_in: (B, L) token ids
         L = tgt_in.shape[1]
@@ -319,19 +409,21 @@ class ChartModel(nn.Module):
                 return_extras=False, in_tgt=None):
         # in_tgt: optional corrupted decoder input (e.g. MASKed types for the
         # skeleton->color infill curriculum); gold targets stay = tgt
-        memory = self.encode(mel, gsum=gsum, pos_bucket=pos_bucket)
+        memory = self.encode(mel, gsum=gsum, pos_bucket=pos_bucket)  # CLEAN
+        dec_mem = self.phase_mem(memory, mel)  # phase-conditioned for the decoder
         dec_in = (in_tgt if in_tgt is not None else tgt)[:, :-1]
         L = dec_in.shape[1]
         E = self.emb_matrix()
         import math as _m
         h = nn.functional.embedding(dec_in, E) * _m.sqrt(self.d_model) + self.dec_pos[:L]
         dm = nn.Transformer.generate_square_subsequent_mask(L, device=tgt.device)
-        h = self.decoder(self.dropout(h), memory, tgt_mask=dm,
+        h = self.decoder(self.dropout(h), dec_mem, tgt_mask=dm,
                          tgt_key_padding_mask=dec_in == VOCAB.pad, tgt_is_causal=True)
         logits = h @ E.T
         if not (return_aux or return_extras):
             return logits
         outs = [logits]
+        # aux/ptr/beat heads read the CLEAN memory (no phase leak)
         aux_mem = memory[:, -(WINDOW // 4):]
         outs.append(self.aux(aux_mem).squeeze(-1) if self.aux is not None else None)
         if return_extras:

static/app.css

@@ -594,6 +594,29 @@ audio {
   font-weight: 750;
 }
 
+.model-select {
+  width: 100%;
+  margin-top: 8px;
+  padding: 10px 12px;
+  color: var(--ink);
+  background: var(--surface-solid);
+  border: 1px solid var(--line);
+  border-radius: 10px;
+  font-size: 13px;
+  font-weight: 600;
+  cursor: pointer;
+  transition: border-color .18s, box-shadow .18s;
+}
+
+.model-select:hover {
+  border-color: var(--line-strong);
+}
+
+.model-select:focus-visible {
+  outline: 3px solid rgba(39, 111, 145, .35);
+  outline-offset: 1px;
+}
+
 .range {
   --range-progress: 88.89%;
   width: 100%;

static/app.js

@@ -15,6 +15,7 @@ const ui = {
   fileMeta: $("#file-meta"),
   removeFile: $("#remove-file"),
   fileError: $("#file-error"),
+  model: $("#model"),
   level: $("#level"),
   levelOutput: $("#level-output"),
   bpm: $("#bpm"),
@@ -529,7 +530,8 @@ function requestValues() {
     ui.sampling.checked,
     Number(ui.temperature.value),
     Number(ui.topP.value),
-    Number(ui.drumVolume.value)
+    Number(ui.drumVolume.value),
+    ui.model ? ui.model.value : "v1.7"
   ];
 }
 

static/index.html

@@ -81,6 +81,27 @@
         </div>
 
         <div class="form-section split-rule">
+          <div class="field-group">
+            <div class="label-row">
+              <label for="model">Model</label>
+            </div>
+            <select id="model" class="model-select">
+              <optgroup label="v1.7 — richest patterns (recommended)">
+                <option value="v1.7" selected>v1.7 · 7.9M — best quality</option>
+                <option value="v1.7-small">v1.7-small · 3.6M</option>
+                <option value="v1.7-tiny">v1.7-tiny · 1.4M — fastest</option>
+              </optgroup>
+              <optgroup label="v1.6 — scaling ladder">
+                <option value="v1.6">v1.6 · 7.9M</option>
+                <option value="v1.6-small">v1.6-small · 3.6M</option>
+                <option value="v1.6-tiny">v1.6-tiny · 1.4M</option>
+              </optgroup>
+              <optgroup label="v1.5 — single model">
+                <option value="v1.5">v1.5 · 7.9M</option>
+              </optgroup>
+            </select>
+          </div>
+
           <fieldset class="field-group">
             <legend>Difficulty</legend>
             <div class="course-selector">