Add YaRN/RoPE auto-configuration from training_ctx + target n_ctx

New auto_configure_yarn() derives rope_freq_scale = training_ctx / target_n_ctx
so the effective context matches the user's target, resetting the other YaRN
knobs to llama.cpp defaults. Wired into the YaRN accordion as an
"Auto-configure from training_ctx + n_ctx" button that writes the five
gr.Number inputs back via gr.update. compute() signature unchanged — the
existing estimate()/command_preview() YaRN flow picks up the new values.

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

app.py

@@ -28,6 +28,7 @@ from vramcalc import (
     best_quant,
     min_gpu_setup,
     mmproj_bytes_from_tensors,
+    auto_configure_yarn,
 )
 from vramcalc.presets import PRESETS, PRESET_NAMES
 
@@ -217,6 +218,26 @@ def run_min_gpu_setup(arch_fields, n_ctx, quant, gpu_vram_text, split_mode, main
     return f"{badge} {res.note}\n\nSubset: [{subset}]\n\nTotal: {format_bytes(res.total_bytes)}"
 
 
+def auto_configure_yarn_handler(arch_fields, n_ctx):
+    """Auto-derive YaRN/RoPE params from training_ctx + target n_ctx.
+
+    Writes the five YaRN gr.Number inputs back via gr.update and returns a
+    markdown status line as the sixth output.
+    """
+    arch = _fields_to_arch(arch_fields)
+    cfg = auto_configure_yarn(arch.training_ctx, int(n_ctx or 8192))
+    badge = "✅" if cfg.scaling else "ℹ️"
+    status = f"{badge} {cfg.note}" if cfg.note else ""
+    return (
+        gr.update(value=cfg.rope_freq_scale),
+        gr.update(value=cfg.yarn_ext_factor),
+        gr.update(value=cfg.yarn_attn_factor),
+        gr.update(value=cfg.yarn_beta_fast),
+        gr.update(value=cfg.yarn_beta_slow),
+        status,
+    )
+
+
 def _arch_to_fields(m: ModelArch):
     return [
         m.name, m.architecture, m.n_layer, m.n_embd, m.n_head, m.n_head_kv,
@@ -529,6 +550,11 @@ def build_ui():
                     with gr.Row():
                         yarn_beta_fast = gr.Number(label="yarn_beta_fast", value=32.0)
                         yarn_beta_slow = gr.Number(label="yarn_beta_slow", value=1.0)
+                    with gr.Row():
+                        yarn_auto_btn = gr.Button(
+                            "Auto-configure from training_ctx + n_ctx"
+                        )
+                        yarn_auto_status = gr.Markdown("")
 
                 with gr.Accordion("Speculative decoding (draft model)", open=False):
                     spec_type = gr.Dropdown(
@@ -701,6 +727,14 @@ def build_ui():
             outputs=[af_mingu_out],
         )
 
+        # YaRN auto-configure: derive rope_freq_scale from training_ctx + n_ctx
+        yarn_auto_btn.click(
+            fn=auto_configure_yarn_handler,
+            inputs=[arch_state, n_ctx],
+            outputs=[rope_freq_scale, yarn_ext_factor, yarn_attn_factor,
+                     yarn_beta_fast, yarn_beta_slow, yarn_auto_status],
+        )
+
     return demo
 
 

tests/test_vramcalc.py

@@ -10,6 +10,7 @@ from vramcalc import (
     compute_scratch_bytes,
     yarn_effective_context,
     yarn_warnings,
+    auto_configure_yarn,
     gpu_split,
     estimate,
     command_preview,
@@ -155,6 +156,40 @@ def test_yarn_warnings_no_warning_when_within():
     assert w == []
 
 
+def test_auto_configure_yarn_extends():
+    cfg = auto_configure_yarn(8192, 32768)
+    assert cfg.scaling is True
+    assert cfg.rope_freq_scale == 0.25
+    # derived scale yields the requested effective context
+    assert yarn_effective_context(8192, cfg.rope_freq_scale) == 32768
+    # remaining knobs reset to llama.cpp defaults
+    assert cfg.yarn_ext_factor == -1.0
+    assert cfg.yarn_attn_factor == 1.0
+    assert cfg.yarn_beta_fast == 32.0
+    assert cfg.yarn_beta_slow == 1.0
+
+
+def test_auto_configure_yarn_within_training():
+    cfg = auto_configure_yarn(131072, 8192)
+    assert cfg.scaling is False
+    assert cfg.rope_freq_scale == 1.0
+    assert "no YaRN scaling needed" in cfg.note
+
+
+def test_auto_configure_yarn_unknown_training_ctx():
+    cfg = auto_configure_yarn(0, 32768)
+    assert cfg.scaling is False
+    assert cfg.rope_freq_scale == 1.0
+    assert "unknown" in cfg.note.lower()
+
+
+def test_auto_configure_yarn_invalid_target():
+    cfg = auto_configure_yarn(8192, 0)
+    assert cfg.scaling is False
+    assert cfg.rope_freq_scale == 1.0
+    assert "invalid" in cfg.note.lower()
+
+
 def test_gpu_split_layer_distributes_weights_and_kv():
     res = gpu_split(
         gpu_vram_bytes=[24 << 30, 24 << 30, 16 << 30],

vramcalc/__init__.py

@@ -5,7 +5,7 @@ Pure calculation logic, importable without Gradio so it can be unit-tested.
 
 from .quant import QUANT_BPW, weight_bytes, quant_from_filename
 from .kv import kv_cache_bytes, cache_dtype_bytes, compute_scratch_bytes
-from .yarn import yarn_effective_context, yarn_warnings
+from .yarn import yarn_effective_context, yarn_warnings, YarnConfig, auto_configure_yarn
 from .gpu import GpuBudget, GpuSpec, gpu_split, fit_gpus, GpuSplitResult
 from .gguf import (
     GGUFMetadata,
@@ -36,6 +36,8 @@ __all__ = [
     "compute_scratch_bytes",
     "yarn_effective_context",
     "yarn_warnings",
+    "YarnConfig",
+    "auto_configure_yarn",
     "GpuBudget",
     "GpuSpec",
     "GpuSplitResult",

vramcalc/yarn.py

@@ -9,6 +9,60 @@ sanity check.
 
 from __future__ import annotations
 
+from dataclasses import dataclass
+
+
+@dataclass
+class YarnConfig:
+    """Recommended YaRN/RoPE parameters for a target context.
+
+    ``rope_freq_scale`` is the only value we actually derive; the rest are the
+    llama.cpp defaults (matching :class:`vramcalc.report.Inputs`) so a stale
+    manual tweak can't linger after auto-configuration.
+    """
+    rope_freq_scale: float = 1.0
+    yarn_ext_factor: float = -1.0
+    yarn_attn_factor: float = 1.0
+    yarn_beta_fast: float = 32.0
+    yarn_beta_slow: float = 1.0
+    scaling: bool = False          # True when target > training_ctx (yarn needed)
+    note: str = ""                 # human-readable explanation / caveats
+
+
+def auto_configure_yarn(training_ctx: int, target_n_ctx: int) -> YarnConfig:
+    """Derive recommended YaRN/RoPE params from training_ctx + a target n_ctx.
+
+    The llama.cpp long-context recipe is ``--rope-scaling yarn`` with
+    ``rope_freq_scale = training_ctx / target_n_ctx`` (so the effective context
+    matches the target), leaving extrapolation/attention/beta at their defaults.
+    Returns a :class:`YarnConfig` with everything reset to those defaults when no
+    extension is needed or the inputs are unusable.
+    """
+    if target_n_ctx is None or target_n_ctx <= 0:
+        return YarnConfig(note="Target context is invalid; nothing to configure.")
+    if training_ctx is None or training_ctx <= 0:
+        return YarnConfig(
+            note="Training context unknown — fetch a GGUF or load a preset, "
+                 "or set rope_freq_scale manually.",
+        )
+    if target_n_ctx <= training_ctx:
+        return YarnConfig(
+            note=f"Target context {target_n_ctx} is within training context "
+                 f"{training_ctx}; no YaRN scaling needed.",
+        )
+    scale = round(training_ctx / target_n_ctx, 6)
+    if scale <= 0:
+        return YarnConfig(note="Target context is invalid; nothing to configure.")
+    eff = yarn_effective_context(training_ctx, scale)
+    stretch = (1.0 / scale) if scale else 0.0
+    return YarnConfig(
+        rope_freq_scale=scale,
+        scaling=True,
+        note=f"Set rope_freq_scale={scale} so effective context ≈ {eff} "
+             f"(training_ctx {training_ctx} × {stretch:.1f}×). "
+             f"YaRN extrapolation auto (--yarn-ext-factor -1).",
+    )
+
 
 def yarn_effective_context(training_ctx: int, rope_freq_scale: float) -> int:
     """Effective (interpolated) context given a rope_freq_scale.