Gradio demo: 6 vineyard plotting-code LoRA adapters with sandboxed execution

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+models/qwen2.5-coder-0.5b-plotter-lora/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+models/qwen2.5-coder-1.5b-plotter-lora/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+models/qwen2.5-coder-1.5b-plotter-lora-bf16/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+models/qwen2.5-coder-1.5b-plotter-lora-bf16-best/tokenizer.json filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,13 +1,58 @@
 ---
-title: Vineyard Plotter Models
-emoji: ⚡
-colorFrom: indigo
-colorTo: indigo
+title: Vineyard Plotting-Code Models
+emoji: 🍇
+colorFrom: purple
+colorTo: green
 sdk: gradio
 sdk_version: 6.22.0
 python_version: '3.12'
 app_file: app.py
 pinned: false
+license: other
+short_description: Six LoRA adapters that plot vineyard data
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🍇 Vineyard plotting-code models
+
+Six LoRA adapters fine-tuned to write matplotlib/seaborn code against synthetic
+vineyard DataFrames. Pick an adapter from the dropdown, pick one of the 12
+DataFrames, and ask for a chart.
+
+**The generated code is then executed** in a short-lived subprocess and the chart
+shown is the one it actually produced — the same execution check the offline
+evaluation scores, so nothing here can pass off plausible-looking code that does
+not run.
+
+## What's in the dropdown
+
+| Model | Base | Adapter |
+|---|---|---|
+| Qwen2.5-Coder-0.5B · bf16 | `Qwen/Qwen2.5-Coder-0.5B-Instruct` | `models/qwen2.5-coder-0.5b-plotter-lora` |
+| Qwen2.5-Coder-1.5B · bf16 (best checkpoint) | `unsloth/Qwen2.5-Coder-1.5B-Instruct` | `models/qwen2.5-coder-1.5b-plotter-lora-bf16-best` |
+| Qwen2.5-Coder-1.5B · bf16 (final step) | `unsloth/Qwen2.5-Coder-1.5B-Instruct` | `models/qwen2.5-coder-1.5b-plotter-lora-bf16` |
+| Qwen2.5-Coder-1.5B · 4-bit NF4 run | `Qwen/Qwen2.5-Coder-1.5B-Instruct` | `models/qwen2.5-coder-1.5b-plotter-lora` |
+| Phi-3.5-mini-instruct · 3.8B | `microsoft/Phi-3.5-mini-instruct` | `models/phi35-mini-instruct-lora` |
+| LFM2-2.6B | `LiquidAI/LFM2-2.6B` | `models/lfm-2.6b-lora` |
+
+The **"Use the fine-tuned adapter"** checkbox turns the adapter off, so you can
+run the same prompt against the untuned base and see what the fine-tuning bought.
+On the 0.5B, the honest answer is house style rather than reliability: the adapter
+takes `tight_layout()` from 1/10 to 10/10 and drops invented columns to 0/10,
+without improving execution pass rate.
+
+## How the prompt is built
+
+Identical to training, or the model is off-distribution. A fixed system turn,
+then a user turn holding the DataFrame preview (`schemas.df_preview` — the single
+source of truth for that string) followed by the request.
+
+## Notes
+
+- The first request for a given model downloads its base weights; later ones are
+  cached. Only one model is held in memory at a time.
+- Generated code runs with restricted builtins — no `os`, `open`, `eval`,
+  `compile`, `subprocess` — and only data/plotting imports. That is a
+  proportionate guard against hallucinated code, not a hardened sandbox.
+- Base model licences differ: Qwen2.5-Coder is Apache-2.0, Phi-3.5-mini is MIT,
+  LFM2 is under the LFM Open License. The adapters are derivative of their
+  respective bases.

app.py

@@ -0,0 +1,327 @@
+"""Gradio demo for the vineyard plotting-code LoRA adapters.
+
+Pick an adapter from the dropdown, pick one of the 12 synthetic vineyard
+DataFrames, ask for a chart. The Space generates the plotting code, then runs it
+in a subprocess sandbox and shows you the chart it actually produced -- the same
+execution check `pipeline/evaluate.py` scores offline, so a demo can't pass off
+plausible-looking code that doesn't run.
+
+Runs on ZeroGPU when the Space has it, and falls back to CPU otherwise.
+"""
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import gradio as gr
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from execute import clean_code_string
+from schemas import GENERATORS, df_preview
+
+# ZeroGPU: only the decorated function gets a real GPU. Outside it, PyTorch runs
+# in a CUDA emulation mode -- which is why weights are placed on `cuda` in the
+# parent process (see _load) and the decorated function only does the forward
+# pass. The decorated call inherits the parent's state, so the model cache below
+# survives; loading inside the decorator instead would re-download and re-place
+# the weights on every single request and burn the daily GPU quota doing it.
+#
+# On a CPU Space the import fails and everything below runs unchanged on CPU.
+def _duration(label, *_args, **_kwargs):
+    """Ask for only as much GPU time as the chosen model plausibly needs."""
+    return 45 if "0.5B" in label else 90
+
+
+try:
+    import spaces
+
+    GPU = spaces.GPU(duration=_duration)
+    ZERO_GPU = True
+except Exception:  # noqa: BLE001
+    def GPU(fn):
+        return fn
+
+    ZERO_GPU = False
+
+HERE = Path(__file__).resolve().parent
+GEN_BY_NAME = {g.__name__: g for g in GENERATORS}
+SCHEMAS = sorted(GEN_BY_NAME)
+
+# MUST match pipeline/build_dataset.py SYSTEM_PROMPT exactly. Every training
+# example carried this system turn; changing a word moves the prompt off the
+# distribution the adapters were tuned on.
+SYSTEM_PROMPT = (
+    "You write Python plotting code for vineyard / viticulture data. "
+    "A pandas DataFrame `df` is already loaded. Return only a ```python "
+    "code block using matplotlib or seaborn."
+)
+
+# label -> (base repo on the Hub, adapter dir in this repo, blurb for the UI)
+MODELS = {
+    "Qwen2.5-Coder-0.5B · bf16": (
+        "Qwen/Qwen2.5-Coder-0.5B-Instruct",
+        "models/qwen2.5-coder-0.5b-plotter-lora",
+        "Trained in bf16. Best scorecard of the set: 6/10 semantically correct, "
+        "0/10 invented columns, 10/10 `tight_layout()`. Fastest to load.",
+    ),
+    "Qwen2.5-Coder-1.5B · bf16 (best checkpoint)": (
+        "unsloth/Qwen2.5-Coder-1.5B-Instruct",
+        "models/qwen2.5-coder-1.5b-plotter-lora-bf16-best",
+        "The checkpoint selected on eval loss rather than the final step. "
+        "Start here if you want the 1.5B.",
+    ),
+    "Qwen2.5-Coder-1.5B · bf16 (final step)": (
+        "unsloth/Qwen2.5-Coder-1.5B-Instruct",
+        "models/qwen2.5-coder-1.5b-plotter-lora-bf16",
+        "Same run, saved at the last step instead of the best one.",
+    ),
+    "Qwen2.5-Coder-1.5B · 4-bit NF4 run": (
+        "Qwen/Qwen2.5-Coder-1.5B-Instruct",
+        "models/qwen2.5-coder-1.5b-plotter-lora",
+        "The original 1.5B, trained under 4-bit NF4 because bf16 would not fit "
+        "the training card. Overfit at step 186 (eval loss 0.599 vs 0.480 at "
+        "step 100) — kept for comparison. Served here in bf16.",
+    ),
+    "Phi-3.5-mini-instruct · 3.8B": (
+        "microsoft/Phi-3.5-mini-instruct",
+        "models/phi35-mini-instruct-lora",
+        "Largest base in the set. Slowest to load on a cold Space.",
+    ),
+    "LFM2-2.6B": (
+        "LiquidAI/LFM2-2.6B",
+        "models/lfm-2.6b-lora",
+        "Liquid AI's hybrid-conv base — a different architecture family from the "
+        "others.",
+    ),
+}
+DEFAULT_MODEL = "Qwen2.5-Coder-0.5B · bf16"
+
+# One model resident at a time: the big bases will not co-exist in Space RAM.
+_LOADED: dict = {"key": None, "model": None, "tokenizer": None}
+
+
+def _load(label: str, use_adapter: bool):
+    """Base model + (optionally) the LoRA adapter, cached across calls."""
+    key = (label, use_adapter)
+    if _LOADED["key"] == key:
+        return _LOADED["model"], _LOADED["tokenizer"]
+
+    repo, adapter_rel, _ = MODELS[label]
+    adapter = HERE / adapter_rel
+
+    # Evict first -- loading the new weights before freeing the old ones is what
+    # actually OOMs the box.
+    _LOADED.update(key=None, model=None, tokenizer=None)
+    try:
+        torch.cuda.empty_cache()
+    except Exception:  # noqa: BLE001 -- no-op under ZeroGPU's CUDA emulation
+        pass
+
+    # Prefer the tokenizer saved beside the adapter: it carries the exact chat
+    # template training used, so prompts here are formatted identically.
+    tok_src = str(adapter) if (adapter / "tokenizer_config.json").exists() else repo
+    tokenizer = AutoTokenizer.from_pretrained(tok_src)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    # bf16 on any GPU we can land on; CPU has no usable bf16 matmul path here.
+    dtype = torch.bfloat16 if torch.cuda.is_available() else torch.float32
+
+    model = AutoModelForCausalLM.from_pretrained(repo, dtype=dtype)
+    if use_adapter:
+        from peft import PeftModel
+
+        model = PeftModel.from_pretrained(model, str(adapter))
+    model.to("cuda" if torch.cuda.is_available() else "cpu")
+    model.eval()
+
+    _LOADED.update(key=key, model=model, tokenizer=tokenizer)
+    return model, tokenizer
+
+
+@GPU
+def _generate(label, preview, request, max_new_tokens, temperature):
+    """Forward pass only. _load() must already have run in the parent process."""
+    model, tokenizer = _LOADED["model"], _LOADED["tokenizer"]
+
+    # Same three-part shape build_dataset.py wrote, minus the assistant answer.
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {
+            "role": "user",
+            "content": f"### DataFrame Preview:\n{preview}\n\n"
+                       f"### Visualization Request:\n{request}",
+        },
+    ]
+    prompt = tokenizer.apply_chat_template(
+        messages, tokenize=False, add_generation_prompt=True
+    )
+    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+
+    with torch.no_grad():
+        out = model.generate(
+            **inputs,
+            max_new_tokens=int(max_new_tokens),
+            do_sample=temperature > 0,
+            temperature=temperature if temperature > 0 else None,
+            pad_token_id=tokenizer.pad_token_id,
+        )
+    return tokenizer.decode(
+        out[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True
+    ).strip()
+
+
+def _render(schema: str, code: str, seed: int):
+    """Execute the generated code out-of-process; return (ok, error, png path)."""
+    png = Path(tempfile.mkdtemp(prefix="chart_")) / "chart.png"
+    payload = json.dumps(
+        {"schema": schema, "code": code, "seed": int(seed), "png": str(png)}
+    )
+    try:
+        proc = subprocess.run(
+            [sys.executable, str(HERE / "sandbox_runner.py")],
+            input=payload,
+            capture_output=True,
+            text=True,
+            timeout=45,
+            cwd=str(HERE),
+            env={**os.environ, "MPLBACKEND": "Agg"},
+        )
+    except subprocess.TimeoutExpired:
+        return False, "timed out after 45s (likely an unbounded loop)", None
+
+    line = (proc.stdout or "").strip().splitlines()
+    if not line:
+        return False, f"sandbox produced no result. stderr: {(proc.stderr or '')[-400:]}", None
+    try:
+        res = json.loads(line[-1])
+    except json.JSONDecodeError:
+        return False, f"unreadable sandbox output: {line[-1][:300]}", None
+    return res["ok"], res["error"], res["png"]
+
+
+def preview_for(schema: str, seed: int) -> str:
+    return df_preview(GEN_BY_NAME[schema](seed=int(seed)))
+
+
+def model_blurb(label: str) -> str:
+    repo, adapter, note = MODELS[label]
+    return f"**Base:** `{repo}` · **Adapter:** `{adapter}`\n\n{note}"
+
+
+def run(schema, seed, request, label, use_adapter, max_new_tokens, temperature,
+        progress=gr.Progress()):
+    request = (request or "").strip()
+    if not request:
+        return "", "Type a visualization request first.", None
+
+    preview = preview_for(schema, seed)
+
+    progress(0.1, desc=f"Loading {label}…")
+    try:
+        _load(label, use_adapter)
+    except Exception as e:  # noqa: BLE001
+        return "", f"❌ Could not load {label} — {type(e).__name__}: {e}", None
+
+    progress(0.4, desc="Generating…")
+    try:
+        reply = _generate(label, preview, request, max_new_tokens, temperature)
+    except Exception as e:  # noqa: BLE001
+        return "", f"❌ Generation failed — {type(e).__name__}: {e}", None
+
+    code = clean_code_string(reply) or reply
+
+    progress(0.8, desc="Executing in the sandbox…")
+    ok, err, png = _render(schema, code, seed)
+    status = "✅ Code executed and produced a chart." if ok else f"❌ Did not run — {err}"
+    return code, status, png
+
+
+EXAMPLES = [
+    ["block_vintage_df", "Show average yield per acre by block as a bar chart."],
+    ["barrel_aging_df", "Vanillin concentration vs months in barrel, coloured by barrel type."],
+    ["cellar_ferment_df", "Plot fermentation temperature over time for each tank."],
+    ["irrigation_sensor_df", "Distribution of soil moisture readings by sensor depth."],
+    ["wine_sales_df", "Monthly revenue trend broken down by channel."],
+    ["berry_chem_df", "Relationship between brix and titratable acidity."],
+]
+
+CSS = """
+.small-note { font-size: 0.85rem; opacity: 0.75; }
+"""
+
+with gr.Blocks(title="Vineyard Plotting-Code Models") as demo:
+    gr.Markdown(
+        "# 🍇 Vineyard plotting-code models\n"
+        "Six LoRA adapters fine-tuned to write matplotlib/seaborn code against "
+        "synthetic vineyard DataFrames. Pick one, pick a DataFrame, ask for a "
+        "chart. **The generated code is then executed in a sandbox** and the "
+        "chart below is what it actually produced — not a mock-up."
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            model = gr.Dropdown(
+                sorted(MODELS), value=DEFAULT_MODEL, label="Model"
+            )
+            blurb = gr.Markdown(model_blurb(DEFAULT_MODEL), elem_classes="small-note")
+            use_adapter = gr.Checkbox(
+                value=True,
+                label="Use the fine-tuned adapter",
+                info="Uncheck to run the untuned base model for comparison.",
+            )
+            schema = gr.Dropdown(
+                SCHEMAS, value="block_vintage_df", label="DataFrame"
+            )
+            seed = gr.Number(value=0, precision=0, label="Seed")
+            request = gr.Textbox(
+                label="Visualization request",
+                placeholder="Show average yield per acre by block as a bar chart.",
+                lines=3,
+            )
+            with gr.Accordion("Decoding", open=False):
+                max_new_tokens = gr.Slider(64, 768, value=512, step=32,
+                                           label="Max new tokens")
+                temperature = gr.Slider(0.0, 1.0, value=0.2, step=0.05,
+                                        label="Temperature (0 = greedy)")
+            go = gr.Button("Generate chart", variant="primary")
+
+        with gr.Column(scale=1):
+            status = gr.Markdown("")
+            chart = gr.Image(label="Rendered chart", type="filepath", height=380)
+            code_out = gr.Code(label="Generated code", language="python")
+
+    with gr.Accordion("DataFrame the model is shown", open=False):
+        preview = gr.Textbox(
+            value=preview_for("block_vintage_df", 0),
+            label="Preview (exactly the string passed to the model)",
+            lines=10, max_lines=14,
+        )
+
+    gr.Examples(EXAMPLES, inputs=[schema, request], label="Try one")
+
+    gr.Markdown(
+        f"Running on **{'ZeroGPU' if ZERO_GPU else 'CPU'}**. The first request for "
+        "a given model downloads its base weights and is slower than the rest.\n\n"
+        "Generated code runs with restricted builtins (no `os`, `open`, `eval`, "
+        "`subprocess`) in a separate short-lived process — a proportionate guard "
+        "against hallucinated code, not a hardened sandbox.",
+        elem_classes="small-note",
+    )
+
+    model.change(model_blurb, model, blurb)
+    for comp in (schema, seed):
+        comp.change(preview_for, [schema, seed], preview)
+
+    go.click(
+        run,
+        [schema, seed, request, model, use_adapter, max_new_tokens, temperature],
+        [code_out, status, chart],
+    )
+
+if __name__ == "__main__":
+    demo.queue(max_size=12).launch(css=CSS)

execute.py

@@ -0,0 +1,180 @@
+"""Sandboxed execution + validation of generated plotting code."""
+
+import multiprocessing as mp
+import re
+import matplotlib
+
+matplotlib.use("Agg")  # Headless mode
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+
+try:
+    import seaborn as sns
+except ImportError:
+    sns = None
+
+from schemas import GENERATORS
+
+# ---------------------------------------------------------------------------
+# Execution guard
+# ---------------------------------------------------------------------------
+# The code we exec() here is machine-generated (Gemini teacher, and later the
+# fine-tuned student). It is NOT trusted. Running it with the full builtins and
+# unrestricted imports would let a hallucinated snippet run `import os;
+# os.system(...)`, delete files, or open network sockets on this machine.
+#
+# This is a *proportionate* guard against accidental / hallucinated harm, not a
+# hardened sandbox: it removes the obvious escape hatches (open/eval/exec/compile
+# and imports of os/subprocess/socket/etc.) while still allowing normal plotting
+# code. For genuinely adversarial code, run this inside a container or VM.
+
+# Top-level modules a plotting snippet is allowed to import.
+_ALLOWED_IMPORTS = {
+    "matplotlib", "mpl_toolkits", "pandas", "numpy", "seaborn",
+    "scipy", "math", "statistics", "datetime", "collections",
+    "itertools", "functools", "warnings", "random", "cycler",
+    "numbers", "decimal", "fractions",
+}
+
+# Builtins safe to expose. Deliberately omits open, eval, exec, compile, input,
+# __import__ (replaced below), globals, locals, vars, exit, quit, help,
+# breakpoint, memoryview.
+_SAFE_BUILTIN_NAMES = (
+    "abs", "all", "any", "bool", "bytes", "callable", "chr", "classmethod",
+    "complex", "dict", "divmod", "enumerate", "filter", "float", "format",
+    "frozenset", "getattr", "hasattr", "hash", "hex", "int", "isinstance",
+    "issubclass", "iter", "len", "list", "map", "max", "min", "next", "object",
+    "oct", "ord", "pow", "print", "property", "range", "repr", "reversed",
+    "round", "set", "setattr", "slice", "sorted", "staticmethod", "str", "sum",
+    "super", "tuple", "type", "zip", "True", "False", "None",
+    "__build_class__",  # needed for class definitions in generated code
+)
+
+
+def _guarded_import(name, globals=None, locals=None, fromlist=(), level=0):
+    """Allow imports only for the whitelisted data/plotting modules."""
+    root = name.split(".")[0]
+    if root not in _ALLOWED_IMPORTS:
+        raise ImportError(f"import of '{name}' is blocked in the execution sandbox")
+    return __import__(name, globals, locals, fromlist, level)
+
+
+def _safe_builtins() -> dict:
+    import builtins as _b
+    safe = {n: getattr(_b, n) for n in _SAFE_BUILTIN_NAMES if hasattr(_b, n)}
+    safe["__import__"] = _guarded_import
+    return safe
+
+
+GENERATOR_MAP = (
+    {g.__name__: g if callable(g) else g for g in GENERATORS}
+    if isinstance(GENERATORS, (list, tuple, set))
+    else GENERATORS
+)
+
+
+def clean_code_string(code: str) -> str:
+    """Strip markdown code blocks from generated code safely."""
+    if not code:
+        return ""
+
+    code = code.strip()
+    bt3 = chr(96) * 3  # Dynamically generates triple backticks to avoid UI glitches
+
+    # Extract content inside markdown python code block if present
+    pattern = bt3 + r"(?:python)?\s*\n?(.*?)\n?" + bt3
+    match = re.search(pattern, code, flags=re.DOTALL | re.IGNORECASE)
+    
+    if match:
+        cleaned = match.group(1).strip()
+    else:
+        # Fallback: strip leading/trailing backtick lines
+        lines = code.splitlines()
+        if lines and lines[0].strip().startswith(bt3):
+            lines = lines[1:]
+        if lines and lines[-1].strip().startswith(bt3):
+            lines = lines[:-1]
+        cleaned = "\n".join(lines).strip()
+
+    return cleaned
+
+
+def _run(gen_name: str, code: str, q: mp.Queue, seed: int = 0) -> None:
+    # Generated code triggers a lot of library deprecation chatter (seaborn
+    # palette/hue, pandas futures). It is not our code and we cannot fix it, so
+    # keep it out of the validation log -- real failures come back via the queue.
+    import warnings
+    warnings.filterwarnings("ignore")
+    try:
+        if callable(gen_name):
+            gen_func = gen_name
+        elif gen_name in GENERATOR_MAP:
+            gen_func = GENERATOR_MAP[gen_name]
+        else:
+            q.put(("error", f"Generator '{gen_name}' not found."))
+            return
+
+        clean_code = clean_code_string(code)
+        if not clean_code:
+            q.put(("error", "Empty code block after stripping formatting."))
+            return
+
+        # Same (generator, seed) the teacher saw -> the code is validated against
+        # the exact DataFrame whose preview is stored on the record.
+        df = gen_func(seed=seed)
+
+        ns = {
+            "df": df,
+            "plt": plt,
+            "pd": pd,
+            "np": np,
+            "matplotlib": matplotlib,
+            "__builtins__": _safe_builtins(),  # restricted: no os/open/eval/etc.
+        }
+        if sns is not None:
+            ns["sns"] = sns
+
+        plt.close("all")
+        exec(clean_code, ns)
+
+        fignums = plt.get_fignums()
+        if not fignums:
+            q.put(("no_figure", "No matplotlib figure was created."))
+            return
+
+        fig = plt.gcf()
+        has_axes = len(fig.axes) > 0 and any(len(ax.get_children()) > 0 for ax in fig.axes)
+        plt.close("all")
+
+        if has_axes:
+            q.put(("ok", None))
+        else:
+            q.put(("no_figure", "Figure created but contains no axes or visual elements."))
+    except Exception as e:
+        plt.close("all")
+        q.put(("error", f"{type(e).__name__}: {str(e)}"))
+
+
+def validate(gen_name: str, code: str, timeout: int = 10, seed: int = 0) -> tuple[bool, str | None]:
+    if not code:
+        return False, "empty code"
+
+    q = mp.Queue()
+    p = mp.Process(target=_run, args=(gen_name, code, q, seed))
+    p.start()
+    p.join(timeout)
+
+    if p.is_alive():
+        p.terminate()
+        p.join(timeout=2)
+        if p.is_alive():
+            p.kill()
+            p.join()
+        return False, f"Timeout after {timeout} seconds"
+
+    if q.empty():
+        return False, "Process terminated unexpectedly with no output"
+
+    status, detail = q.get()
+    return status == "ok", detail

models/lfm-2.6b-lora/adapter_config.json

@@ -0,0 +1,51 @@
+{
+  "alora_invocation_tokens": null,
+  "alpha_pattern": {},
+  "arrow_config": null,
+  "auto_mapping": null,
+  "base_model_name_or_path": "LiquidAI/LFM2-2.6B",
+  "bias": "none",
+  "corda_config": null,
+  "ensure_weight_tying": false,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 32,
+  "lora_bias": false,
+  "lora_dropout": 0.05,
+  "lora_ga_config": null,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "monteclora_config": null,
+  "peft_type": "LORA",
+  "peft_version": "0.20.0",
+  "qalora_group_size": 16,
+  "r": 16,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "w2",
+    "v_proj",
+    "q_proj",
+    "out_proj",
+    "k_proj",
+    "in_proj",
+    "w1",
+    "w3"
+  ],
+  "target_parameters": null,
+  "task_type": "CAUSAL_LM",
+  "trainable_token_indices": null,
+  "use_bdlora": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false,
+  "velora_config": null
+}

models/lfm-2.6b-lora/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:019e3d4f771171e4796551056daa6b61bf36904d1c8d0b923457caa5d34dc2c2
+size 97889536

models/lfm-2.6b-lora/chat_template.jinja

@@ -0,0 +1,7 @@
+{{- bos_token -}}{%- set system_prompt = "" -%}{%- set ns = namespace(system_prompt="") -%}{%- if messages[0]["role"] == "system" -%} {%- set ns.system_prompt = messages[0]["content"] -%} {%- set messages = messages[1:] -%}{%- endif -%}{%- if tools -%} {%- set ns.system_prompt = ns.system_prompt + ("
+" if ns.system_prompt else "") + "List of tools: <|tool_list_start|>[" -%} {%- for tool in tools -%} {%- if tool is not string -%} {%- set tool = tool | tojson -%} {%- endif -%} {%- set ns.system_prompt = ns.system_prompt + tool -%} {%- if not loop.last -%} {%- set ns.system_prompt = ns.system_prompt + ", " -%} {%- endif -%} {%- endfor -%} {%- set ns.system_prompt = ns.system_prompt + "]<|tool_list_end|>" -%}{%- endif -%}{%- if ns.system_prompt -%} {{- "<|im_start|>system
+" + ns.system_prompt + "<|im_end|>
+" -}}{%- endif -%}{%- for message in messages -%} {{- "<|im_start|>" + message["role"] + "
+" -}} {%- set content = message["content"] -%} {%- if content is not string -%} {%- set content = content | tojson -%} {%- endif -%} {%- if message["role"] == "tool" -%} {%- set content = "<|tool_response_start|>" + content + "<|tool_response_end|>" -%} {%- endif -%} {{- content + "<|im_end|>
+" -}}{%- endfor -%}{%- if add_generation_prompt -%} {{- "<|im_start|>assistant
+" -}}{%- endif -%}

models/lfm-2.6b-lora/tokenizer_config.json

@@ -0,0 +1,20 @@
+{
+  "backend": "tokenizers",
+  "bos_token": "<|startoftext|>",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "is_local": false,
+  "legacy": true,
+  "local_files_only": false,
+  "model_input_names": [
+    "input_ids",
+    "attention_mask"
+  ],
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "<|pad|>",
+  "sp_model_kwargs": {},
+  "spaces_between_special_tokens": false,
+  "tokenizer_class": "TokenizersBackend",
+  "use_default_system_prompt": false,
+  "use_fast": true
+}

models/phi35-mini-instruct-lora/adapter_config.json

@@ -0,0 +1,47 @@
+{
+  "alora_invocation_tokens": null,
+  "alpha_pattern": {},
+  "arrow_config": null,
+  "auto_mapping": null,
+  "base_model_name_or_path": "microsoft/Phi-3.5-mini-instruct",
+  "bias": "none",
+  "corda_config": null,
+  "ensure_weight_tying": false,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 32,
+  "lora_bias": false,
+  "lora_dropout": 0.05,
+  "lora_ga_config": null,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "monteclora_config": null,
+  "peft_type": "LORA",
+  "peft_version": "0.20.0",
+  "qalora_group_size": 16,
+  "r": 16,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "qkv_proj",
+    "o_proj",
+    "gate_up_proj",
+    "down_proj"
+  ],
+  "target_parameters": null,
+  "task_type": "CAUSAL_LM",
+  "trainable_token_indices": null,
+  "use_bdlora": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false,
+  "velora_config": null
+}

models/phi35-mini-instruct-lora/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e56d14e2dd4b10649767db1068d1abbae6fb5e8036fec689d2b27fe616da54a0
+size 100697728

models/phi35-mini-instruct-lora/chat_template.jinja

@@ -0,0 +1,8 @@
+{% for message in messages %}{% if message['role'] == 'system' and message['content'] %}{{'<|system|>
+' + message['content'] + '<|end|>
+'}}{% elif message['role'] == 'user' %}{{'<|user|>
+' + message['content'] + '<|end|>
+'}}{% elif message['role'] == 'assistant' %}{{'<|assistant|>
+' + message['content'] + '<|end|>
+'}}{% endif %}{% endfor %}{% if add_generation_prompt %}{{ '<|assistant|>
+' }}{% else %}{{ eos_token }}{% endif %}

models/phi35-mini-instruct-lora/tokenizer_config.json

@@ -0,0 +1,16 @@
+{
+  "backend": "tokenizers",
+  "bos_token": "<s>",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|endoftext|>",
+  "is_local": false,
+  "legacy": false,
+  "local_files_only": false,
+  "model_max_length": 131072,
+  "pad_token": "<|endoftext|>",
+  "padding_side": "left",
+  "sp_model_kwargs": {},
+  "tokenizer_class": "TokenizersBackend",
+  "unk_token": "<unk>",
+  "use_default_system_prompt": false
+}

models/qwen2.5-coder-0.5b-plotter-lora/adapter_config.json

@@ -0,0 +1,50 @@
+{
+  "alora_invocation_tokens": null,
+  "alpha_pattern": {},
+  "arrow_config": null,
+  "auto_mapping": null,
+  "base_model_name_or_path": "Qwen/Qwen2.5-Coder-0.5B-Instruct",
+  "bias": "none",
+  "corda_config": null,
+  "ensure_weight_tying": false,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 16,
+  "lora_bias": false,
+  "lora_dropout": 0.0,
+  "lora_ga_config": null,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "monteclora_config": null,
+  "peft_type": "LORA",
+  "peft_version": "0.20.0",
+  "qalora_group_size": 16,
+  "r": 16,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "v_proj",
+    "down_proj",
+    "up_proj",
+    "gate_proj",
+    "q_proj",
+    "o_proj",
+    "k_proj"
+  ],
+  "target_parameters": null,
+  "task_type": "CAUSAL_LM",
+  "trainable_token_indices": null,
+  "use_bdlora": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false,
+  "velora_config": null
+}

models/qwen2.5-coder-0.5b-plotter-lora/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:74d19b0e08af9b3ec3b0d5cac0779243a754dec11e6cd7bdcd7cfd98d6f602cf
+size 35237104

models/qwen2.5-coder-0.5b-plotter-lora/chat_template.jinja

@@ -0,0 +1,54 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- messages[0]['content'] }}
+    {%- else %}
+        {{- 'You are Qwen, created by Alibaba Cloud. You are a helpful assistant.' }}
+    {%- endif %}
+    {{- "\n\n# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0]['content'] + '<|im_end|>\n' }}
+    {%- else %}
+        {{- '<|im_start|>system\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- for message in messages %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) or (message.role == "assistant" and not message.tool_calls) %}
+        {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {{- '<|im_start|>' + message.role }}
+        {%- if message.content %}
+            {{- '\n' + message.content }}
+        {%- endif %}
+        {%- for tool_call in message.tool_calls %}
+            {%- if tool_call.function is defined %}
+                {%- set tool_call = tool_call.function %}
+            {%- endif %}
+            {{- '\n<tool_call>\n{"name": "' }}
+            {{- tool_call.name }}
+            {{- '", "arguments": ' }}
+            {{- tool_call.arguments | tojson }}
+            {{- '}\n</tool_call>' }}
+        {%- endfor %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- message.content }}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+{%- endif %}

models/qwen2.5-coder-0.5b-plotter-lora/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3fd169731d2cbde95e10bf356d66d5997fd885dd8dbb6fb4684da3f23b2585d8
+size 11421892

models/qwen2.5-coder-0.5b-plotter-lora/tokenizer_config.json

@@ -0,0 +1,29 @@
+{
+  "add_prefix_space": false,
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "extra_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "is_local": false,
+  "model_max_length": 32768,
+  "pad_token": "<|endoftext|>",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null
+}

models/qwen2.5-coder-1.5b-plotter-lora-bf16-best/adapter_config.json

@@ -0,0 +1,54 @@
+{
+  "alora_invocation_tokens": null,
+  "alpha_pattern": {},
+  "arrow_config": null,
+  "auto_mapping": {
+    "base_model_class": "Qwen2ForCausalLM",
+    "parent_library": "transformers.models.qwen2.modeling_qwen2",
+    "unsloth_fixed": true
+  },
+  "base_model_name_or_path": "unsloth/Qwen2.5-Coder-1.5B-Instruct",
+  "bias": "none",
+  "corda_config": null,
+  "ensure_weight_tying": false,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 16,
+  "lora_bias": false,
+  "lora_dropout": 0.0,
+  "lora_ga_config": null,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "monteclora_config": null,
+  "peft_type": "LORA",
+  "peft_version": "0.20.0",
+  "qalora_group_size": 16,
+  "r": 16,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "up_proj",
+    "gate_proj",
+    "v_proj",
+    "q_proj",
+    "o_proj",
+    "down_proj",
+    "k_proj"
+  ],
+  "target_parameters": null,
+  "task_type": "CAUSAL_LM",
+  "trainable_token_indices": null,
+  "use_bdlora": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false,
+  "velora_config": null
+}

models/qwen2.5-coder-1.5b-plotter-lora-bf16-best/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b48bd5cf9332b2af8815dfcd1ea30ed662b5c2d6b0034d71137a5cca4cc7d0d9
+size 73911112

models/qwen2.5-coder-1.5b-plotter-lora-bf16-best/chat_template.jinja

@@ -0,0 +1,54 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- messages[0]['content'] }}
+    {%- else %}
+        {{- 'You are Qwen, created by Alibaba Cloud. You are a helpful assistant.' }}
+    {%- endif %}
+    {{- "\n\n# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0]['content'] + '<|im_end|>\n' }}
+    {%- else %}
+        {{- '<|im_start|>system\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- for message in messages %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) or (message.role == "assistant" and not message.tool_calls) %}
+        {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {{- '<|im_start|>' + message.role }}
+        {%- if message.content %}
+            {{- '\n' + message.content }}
+        {%- endif %}
+        {%- for tool_call in message.tool_calls %}
+            {%- if tool_call.function is defined %}
+                {%- set tool_call = tool_call.function %}
+            {%- endif %}
+            {{- '\n<tool_call>\n{"name": "' }}
+            {{- tool_call.name }}
+            {{- '", "arguments": ' }}
+            {{- tool_call.arguments | tojson }}
+            {{- '}\n</tool_call>' }}
+        {%- endfor %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- message.content }}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+{%- endif %}

models/qwen2.5-coder-1.5b-plotter-lora-bf16-best/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea43b288542655d72d632195ab9b58ca2cd9532c292bf6667827ce899ad196bc
+size 11422082

models/qwen2.5-coder-1.5b-plotter-lora-bf16-best/tokenizer_config.json

@@ -0,0 +1,216 @@
+{
+  "add_prefix_space": false,
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "extra_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "is_local": false,
+  "model_max_length": 32768,
+  "pad_token": "<|PAD_TOKEN|>",
+  "padding_side": "left",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null,
+  "added_tokens_decoder": {
+    "151643": {
+      "content": "<|endoftext|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151644": {
+      "content": "<|im_start|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151645": {
+      "content": "<|im_end|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151646": {
+      "content": "<|object_ref_start|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151647": {
+      "content": "<|object_ref_end|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151648": {
+      "content": "<|box_start|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151649": {
+      "content": "<|box_end|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151650": {
+      "content": "<|quad_start|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151651": {
+      "content": "<|quad_end|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151652": {
+      "content": "<|vision_start|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151653": {
+      "content": "<|vision_end|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151654": {
+      "content": "<|vision_pad|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151655": {
+      "content": "<|image_pad|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151656": {
+      "content": "<|video_pad|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151657": {
+      "content": "<tool_call>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151658": {
+      "content": "</tool_call>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151659": {
+      "content": "<|fim_prefix|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151660": {
+      "content": "<|fim_middle|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151661": {
+      "content": "<|fim_suffix|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151662": {
+      "content": "<|fim_pad|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151663": {
+      "content": "<|repo_name|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151664": {
+      "content": "<|file_sep|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151665": {
+      "content": "<|PAD_TOKEN|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    }
+  }
+}

models/qwen2.5-coder-1.5b-plotter-lora-bf16/adapter_config.json

@@ -0,0 +1,54 @@
+{
+  "alora_invocation_tokens": null,
+  "alpha_pattern": {},
+  "arrow_config": null,
+  "auto_mapping": {
+    "base_model_class": "Qwen2ForCausalLM",
+    "parent_library": "transformers.models.qwen2.modeling_qwen2",
+    "unsloth_fixed": true
+  },
+  "base_model_name_or_path": "unsloth/Qwen2.5-Coder-1.5B-Instruct",
+  "bias": "none",
+  "corda_config": null,
+  "ensure_weight_tying": false,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 16,
+  "lora_bias": false,
+  "lora_dropout": 0,
+  "lora_ga_config": null,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "monteclora_config": null,
+  "peft_type": "LORA",
+  "peft_version": "0.20.0",
+  "qalora_group_size": 16,
+  "r": 16,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "v_proj",
+    "down_proj",
+    "up_proj",
+    "gate_proj",
+    "o_proj",
+    "k_proj",
+    "q_proj"
+  ],
+  "target_parameters": null,
+  "task_type": "CAUSAL_LM",
+  "trainable_token_indices": null,
+  "use_bdlora": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false,
+  "velora_config": null
+}

models/qwen2.5-coder-1.5b-plotter-lora-bf16/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9b296635344c623b5987481f73f52ea51d411fbb319b555b55f9d4ba633c194a
+size 73911112

models/qwen2.5-coder-1.5b-plotter-lora-bf16/chat_template.jinja

@@ -0,0 +1,54 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- messages[0]['content'] }}
+    {%- else %}
+        {{- 'You are Qwen, created by Alibaba Cloud. You are a helpful assistant.' }}
+    {%- endif %}
+    {{- "\n\n# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0]['content'] + '<|im_end|>\n' }}
+    {%- else %}
+        {{- '<|im_start|>system\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- for message in messages %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) or (message.role == "assistant" and not message.tool_calls) %}
+        {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {{- '<|im_start|>' + message.role }}
+        {%- if message.content %}
+            {{- '\n' + message.content }}
+        {%- endif %}
+        {%- for tool_call in message.tool_calls %}
+            {%- if tool_call.function is defined %}
+                {%- set tool_call = tool_call.function %}
+            {%- endif %}
+            {{- '\n<tool_call>\n{"name": "' }}
+            {{- tool_call.name }}
+            {{- '", "arguments": ' }}
+            {{- tool_call.arguments | tojson }}
+            {{- '}\n</tool_call>' }}
+        {%- endfor %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- message.content }}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+{%- endif %}

models/qwen2.5-coder-1.5b-plotter-lora-bf16/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea43b288542655d72d632195ab9b58ca2cd9532c292bf6667827ce899ad196bc
+size 11422082

models/qwen2.5-coder-1.5b-plotter-lora-bf16/tokenizer_config.json

@@ -0,0 +1,216 @@
+{
+  "add_prefix_space": false,
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "extra_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "is_local": false,
+  "model_max_length": 32768,
+  "pad_token": "<|PAD_TOKEN|>",
+  "padding_side": "left",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null,
+  "added_tokens_decoder": {
+    "151643": {
+      "content": "<|endoftext|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151644": {
+      "content": "<|im_start|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151645": {
+      "content": "<|im_end|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151646": {
+      "content": "<|object_ref_start|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151647": {
+      "content": "<|object_ref_end|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151648": {
+      "content": "<|box_start|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151649": {
+      "content": "<|box_end|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151650": {
+      "content": "<|quad_start|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151651": {
+      "content": "<|quad_end|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151652": {
+      "content": "<|vision_start|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151653": {
+      "content": "<|vision_end|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151654": {
+      "content": "<|vision_pad|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151655": {
+      "content": "<|image_pad|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151656": {
+      "content": "<|video_pad|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    },
+    "151657": {
+      "content": "<tool_call>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151658": {
+      "content": "</tool_call>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151659": {
+      "content": "<|fim_prefix|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151660": {
+      "content": "<|fim_middle|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151661": {
+      "content": "<|fim_suffix|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151662": {
+      "content": "<|fim_pad|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151663": {
+      "content": "<|repo_name|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151664": {
+      "content": "<|file_sep|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": false
+    },
+    "151665": {
+      "content": "<|PAD_TOKEN|>",
+      "single_word": false,
+      "lstrip": false,
+      "rstrip": false,
+      "normalized": false,
+      "special": true
+    }
+  }
+}

models/qwen2.5-coder-1.5b-plotter-lora/adapter_config.json

@@ -0,0 +1,50 @@
+{
+  "alora_invocation_tokens": null,
+  "alpha_pattern": {},
+  "arrow_config": null,
+  "auto_mapping": null,
+  "base_model_name_or_path": "Qwen/Qwen2.5-Coder-1.5B-Instruct",
+  "bias": "none",
+  "corda_config": null,
+  "ensure_weight_tying": false,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 16,
+  "lora_bias": false,
+  "lora_dropout": 0.0,
+  "lora_ga_config": null,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "monteclora_config": null,
+  "peft_type": "LORA",
+  "peft_version": "0.20.0",
+  "qalora_group_size": 16,
+  "r": 16,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "gate_proj",
+    "up_proj",
+    "k_proj",
+    "down_proj",
+    "q_proj",
+    "o_proj",
+    "v_proj"
+  ],
+  "target_parameters": null,
+  "task_type": "CAUSAL_LM",
+  "trainable_token_indices": null,
+  "use_bdlora": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false,
+  "velora_config": null
+}

models/qwen2.5-coder-1.5b-plotter-lora/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a5d0252190788771113123f6949ad11e13960f813e6a769fcad5551c7bd3c20b
+size 73911112

models/qwen2.5-coder-1.5b-plotter-lora/chat_template.jinja

@@ -0,0 +1,54 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- messages[0]['content'] }}
+    {%- else %}
+        {{- 'You are Qwen, created by Alibaba Cloud. You are a helpful assistant.' }}
+    {%- endif %}
+    {{- "\n\n# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0]['content'] + '<|im_end|>\n' }}
+    {%- else %}
+        {{- '<|im_start|>system\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- for message in messages %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) or (message.role == "assistant" and not message.tool_calls) %}
+        {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {{- '<|im_start|>' + message.role }}
+        {%- if message.content %}
+            {{- '\n' + message.content }}
+        {%- endif %}
+        {%- for tool_call in message.tool_calls %}
+            {%- if tool_call.function is defined %}
+                {%- set tool_call = tool_call.function %}
+            {%- endif %}
+            {{- '\n<tool_call>\n{"name": "' }}
+            {{- tool_call.name }}
+            {{- '", "arguments": ' }}
+            {{- tool_call.arguments | tojson }}
+            {{- '}\n</tool_call>' }}
+        {%- endfor %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- message.content }}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+{%- endif %}

models/qwen2.5-coder-1.5b-plotter-lora/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3fd169731d2cbde95e10bf356d66d5997fd885dd8dbb6fb4684da3f23b2585d8
+size 11421892

models/qwen2.5-coder-1.5b-plotter-lora/tokenizer_config.json

@@ -0,0 +1,29 @@
+{
+  "add_prefix_space": false,
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "extra_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "is_local": false,
+  "model_max_length": 32768,
+  "pad_token": "<|endoftext|>",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null
+}

requirements.txt

@@ -0,0 +1,11 @@
+# torch is pinned to a version ZeroGPU explicitly supports (2.8.0 - 2.11.0).
+torch==2.8.0
+transformers>=4.56,<5
+peft>=0.20.0
+accelerate>=1.0.0
+safetensors>=0.4.0
+
+pandas>=2.0
+numpy>=1.26
+matplotlib>=3.7
+seaborn>=0.13

sandbox_runner.py

@@ -0,0 +1,85 @@
+"""Out-of-process runner for model-generated plotting code.
+
+Deliberately a separate script rather than a multiprocessing target: the parent
+holds CUDA state that must not be forked, and re-importing app.py in a child
+would rebuild the whole Gradio UI. The parent calls this with a hard subprocess
+timeout, so a hallucinated `while True:` costs one killed child and nothing else.
+
+Protocol: JSON on stdin -> JSON on stdout.
+    in : {"schema": str, "code": str, "seed": int, "png": str}
+    out: {"ok": bool, "error": str|null, "png": str|null}
+"""
+
+import json
+import sys
+import warnings
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+
+try:
+    import seaborn as sns
+except ImportError:
+    sns = None
+
+from execute import _safe_builtins, clean_code_string
+from schemas import GENERATORS
+
+GEN_BY_NAME = {g.__name__: g for g in GENERATORS}
+
+
+def main():
+    warnings.filterwarnings("ignore")
+    req = json.load(sys.stdin)
+    out = {"ok": False, "error": None, "png": None}
+
+    try:
+        gen = GEN_BY_NAME.get(req["schema"])
+        if gen is None:
+            out["error"] = f"unknown schema '{req['schema']}'"
+            return out
+
+        code = clean_code_string(req["code"])
+        if not code:
+            out["error"] = "empty code block after stripping formatting"
+            return out
+
+        ns = {
+            "df": gen(seed=req.get("seed", 0)),
+            "plt": plt,
+            "pd": pd,
+            "np": np,
+            "matplotlib": matplotlib,
+            "__builtins__": _safe_builtins(),  # no os/open/eval/subprocess
+        }
+        if sns is not None:
+            ns["sns"] = sns
+
+        plt.close("all")
+        exec(code, ns)
+
+        if not plt.get_fignums():
+            out["error"] = "code ran but created no matplotlib figure"
+            return out
+
+        fig = plt.gcf()
+        if not (fig.axes and any(ax.get_children() for ax in fig.axes)):
+            out["error"] = "figure was created but contains no visual elements"
+            return out
+
+        # We save the figure, not the model -- generated code never touches disk.
+        fig.savefig(req["png"], dpi=110, bbox_inches="tight")
+        out["ok"] = True
+        out["png"] = req["png"]
+    except Exception as e:  # noqa: BLE001 -- any failure is a data point, not a crash
+        out["error"] = f"{type(e).__name__}: {e}"
+    finally:
+        plt.close("all")
+    return out
+
+
+if __name__ == "__main__":
+    print(json.dumps(main()))

schemas.py

@@ -0,0 +1,284 @@
+"""Synthetic vineyard / winery DataFrames.
+
+Twelve generators spanning the whole operation -- vineyard block records, field
+time-series, lab chemistry, cellar, soil, pest scouting, sensors, sensory panel,
+logistics, sales, canopy management, and barrel aging.
+
+WHY SO MANY: the student model must learn to READ the schema preview it is given
+and reference those columns. With only a few generators it can instead memorise
+one fixed column vocabulary ("vineyard plot" -> df['brix']) and still drive the
+training loss to zero -- then fail on any unseen DataFrame. Distinct column names
+per generator is what forces the model to actually read the preview.
+
+SEEDING: every generator takes `seed` and builds its OWN Generator, so a call is
+reproducible from (name, seed) alone. This matters because generate_raw.py builds
+a df to write the preview, and execute.py later rebuilds it to validate the code
+-- they must agree. A module-level shared RNG would advance between those two
+calls and hand back different data.
+"""
+import numpy as np
+import pandas as pd
+
+BLOCKS    = ["North Slope", "River Bench", "Hilltop", "Old Vines", "Clay Flat", "East Terrace"]
+VARIETIES = ["Cabernet Sauvignon", "Chardonnay", "Pinot Noir", "Syrah", "Merlot", "Sauvignon Blanc"]
+ROOTSTOCK = ["101-14", "3309C", "SO4", "1103P", "Riparia Gloire"]
+DISEASES  = ["Powdery Mildew", "Downy Mildew", "Botrytis", "None"]
+
+
+def block_vintage_df(n=220, seed=0):
+    """One row per block x vintage: climate, canopy, yield, and quality at harvest."""
+    rng = np.random.default_rng(seed)
+    gdd = rng.normal(1650, 220, n).round(0).clip(900, 2600)
+    # warmer seasons ripen harder: brix tracks GDD, acid falls away as sugar climbs
+    brix = (18 + (gdd - 900) / 1700 * 6 + rng.normal(0, 0.9, n)).round(1).clip(18, 30)
+    return pd.DataFrame({
+        "block":     rng.choice(BLOCKS, n),
+        "variety":   rng.choice(VARIETIES, n),
+        "rootstock": rng.choice(ROOTSTOCK, n),
+        "vintage":   rng.integers(2012, 2025, n),
+        "gdd":                gdd,                                                  # growing degree days
+        "rainfall_mm":        rng.normal(520, 160, n).round(1).clip(120, 1100),
+        "irrigation_mm":      rng.normal(180, 70, n).round(0).clip(0, 400),
+        "yield_tonnes_per_acre": rng.normal(4.2, 1.6, n).round(2).clip(0.5, 9),
+        "brix":               brix,                                                 # sugar
+        "ph":                 rng.normal(3.55, 0.18, n).round(2).clip(3.0, 4.1),
+        "titratable_acidity_gL": (13 - brix * 0.25 + rng.normal(0, 0.7, n)).round(2).clip(3, 11),
+        "disease":            rng.choice(DISEASES, n, p=[0.28, 0.17, 0.15, 0.40]),
+        "vine_age_years":     rng.integers(3, 60, n),
+    })
+
+
+def phenology_df(n=260, seed=0):
+    """Time series across a growing season: berry weight, sugar, acid accumulation."""
+    rng = np.random.default_rng(seed)
+    dates = pd.date_range("2024-04-01", periods=n // 4 + 1, freq="W")
+    reps = np.tile(dates, 4)[:n]
+    # week index drives ripening: sugar up, acid down, veraison sigmoid
+    wk = np.array([(d - dates[0]).days / 7 for d in reps])
+    span = max(wk.max(), 1)
+    return pd.DataFrame({
+        "date":    reps,
+        "block":   rng.choice(BLOCKS, n),
+        "variety": rng.choice(VARIETIES, n),
+        "berry_weight_g":  (0.4 + 1.4 * wk / span + rng.normal(0, 0.15, n)).round(3).clip(0.2, 2.6),
+        "brix":            (6 + 18 * wk / span + rng.normal(0, 1.2, n)).round(1).clip(5, 28),
+        "titratable_acidity_gL": (19 - 12 * wk / span + rng.normal(0, 1.0, n)).round(2).clip(3, 20),
+        "veraison_pct":    (100 / (1 + np.exp(-(wk - span / 2) * 0.8)) + rng.normal(0, 6, n)).round(0).clip(0, 100),
+    })
+
+
+def berry_chem_df(n=200, seed=0):
+    """Lab chemistry samples: phenolics, anthocyanins, tannin by variety/block."""
+    rng = np.random.default_rng(seed)
+    phenolics = rng.normal(55, 15, n).round(1).clip(10, 110)
+    return pd.DataFrame({
+        "sample_id": np.arange(1, n + 1),
+        "block":     rng.choice(BLOCKS, n),
+        "variety":   rng.choice(VARIETIES, n),
+        # anthocyanin and tannin are both phenolic fractions -> they co-vary
+        "anthocyanin_mg_g":  (phenolics * 0.022 + rng.normal(0, 0.22, n)).round(3).clip(0.1, 3.0),
+        "total_phenolics_au": phenolics,
+        "tannin_mg_g":       (phenolics * 0.032 + rng.normal(0, 0.35, n)).round(2).clip(0.3, 4.5),
+        "ph":                rng.normal(3.55, 0.18, n).round(2).clip(3.0, 4.1),
+        "brix":              rng.normal(24.5, 2.2, n).round(1).clip(18, 30),
+    })
+
+
+def cellar_ferment_df(n=240, seed=0):
+    """Daily tank readings through alcoholic fermentation."""
+    rng = np.random.default_rng(seed)
+    day = rng.integers(0, 16, n)
+    sugar = (230 * np.exp(-0.19 * day) + rng.normal(0, 6, n)).round(1).clip(0, 260)
+    return pd.DataFrame({
+        "tank_id":       rng.choice([f"T{i:02d}" for i in range(1, 19)], n),
+        "yeast_strain":  rng.choice(["EC-1118", "RC-212", "D254", "BM4x4", "Native"], n),
+        "day_of_ferment": day,
+        "residual_sugar_gL": sugar,
+        # every gram of sugar consumed becomes roughly 1/17 % alcohol
+        "alcohol_pct":   ((230 - sugar) / 17.0 + rng.normal(0, 0.25, n)).round(2).clip(0, 16),
+        "must_temp_c":   rng.normal(26, 3.5, n).round(1).clip(12, 35),
+        "cap_temp_c":    rng.normal(29, 4.0, n).round(1).clip(14, 40),
+        "free_so2_ppm":  rng.normal(28, 9, n).round(0).clip(0, 60),
+        "volatile_acidity_gL": rng.normal(0.42, 0.14, n).round(3).clip(0.05, 1.2),
+        "punchdowns_per_day": rng.integers(0, 4, n),
+    })
+
+
+def soil_survey_df(n=180, seed=0):
+    """Soil pit descriptions and lab results by depth horizon."""
+    rng = np.random.default_rng(seed)
+    clay = rng.normal(28, 11, n).round(1).clip(3, 65)
+    return pd.DataFrame({
+        "pit_id":        rng.choice([f"P{i:03d}" for i in range(1, 41)], n),
+        "soil_series":   rng.choice(["Bale Loam", "Pleasanton", "Sobrante", "Hambright", "Yolo Silt"], n),
+        "drainage_class": rng.choice(["Well drained", "Moderately well", "Somewhat poor", "Excessive"], n),
+        "horizon_depth_cm": rng.choice([15, 30, 45, 60, 90, 120], n),
+        "clay_pct":      clay,
+        "sand_pct":      (90 - clay + rng.normal(0, 7, n)).round(1).clip(5, 92),
+        "organic_matter_pct": rng.normal(2.1, 0.8, n).round(2).clip(0.2, 6.0),
+        # clay holds cations -> CEC rises with clay fraction
+        "cec_meq_100g":  (clay * 0.42 + rng.normal(0, 2.2, n)).round(1).clip(2, 40),
+        "soil_ph":       rng.normal(6.4, 0.6, n).round(2).clip(4.5, 8.4),
+        "available_water_mm_m": rng.normal(135, 35, n).round(0).clip(40, 240),
+    })
+
+
+def pest_scouting_df(n=280, seed=0):
+    """Weekly scouting walks: pest pressure per row."""
+    rng = np.random.default_rng(seed)
+    incidence = rng.gamma(2.0, 5.5, n).round(1).clip(0, 100)
+    return pd.DataFrame({
+        "scout_date":  np.tile(pd.date_range("2024-05-01", periods=n // 7 + 1, freq="W"), 7)[:n],
+        "block":       rng.choice(BLOCKS, n),
+        "row_number":  rng.integers(1, 61, n),
+        "pest_name":   rng.choice(["Vine Mealybug", "Leafhopper", "Spider Mite",
+                                   "European Grapevine Moth", "Thrips"], n),
+        "incidence_pct": incidence,
+        "severity_index": (incidence / 25 + rng.normal(0, 0.4, n)).round(2).clip(0, 5),
+        "trap_count":   rng.poisson(6, n),
+        "beneficials_count": rng.poisson(3, n),
+        "threshold_exceeded": incidence > 20,
+        "spray_applied": rng.random(n) < 0.3,
+    })
+
+
+def irrigation_sensor_df(n=300, seed=0):
+    """Hourly-to-daily sensor telemetry for irrigation scheduling."""
+    rng = np.random.default_rng(seed)
+    moisture = rng.normal(24, 6, n).round(2).clip(6, 42)
+    return pd.DataFrame({
+        "timestamp":   pd.date_range("2024-06-01", periods=n, freq="6h"),
+        "sensor_id":   rng.choice([f"S-{i:02d}" for i in range(1, 13)], n),
+        "block":       rng.choice(BLOCKS, n),
+        "soil_moisture_vwc": moisture,
+        # drier soil -> more negative (more stressed) stem water potential
+        "stem_water_potential_bar": (-18 + moisture * 0.33 + rng.normal(0, 1.1, n)).round(2).clip(-20, -2),
+        "canopy_temp_c": rng.normal(29, 5, n).round(1).clip(12, 46),
+        "air_temp_c":    rng.normal(26, 6, n).round(1).clip(8, 44),
+        "relative_humidity_pct": rng.normal(52, 16, n).round(0).clip(8, 99),
+        "et0_mm":       rng.gamma(3, 1.6, n).round(2).clip(0.2, 14),
+        "valve_open":   rng.random(n) < 0.22,
+    })
+
+
+def sensory_panel_df(n=260, seed=0):
+    """Blind tasting panel scores, one row per taster x wine."""
+    rng = np.random.default_rng(seed)
+    fruit = rng.normal(6.4, 1.5, n).round(1).clip(1, 10)
+    structure = rng.normal(6.0, 1.6, n).round(1).clip(1, 10)
+    return pd.DataFrame({
+        "wine_code":  rng.choice([f"W{i:03d}" for i in range(1, 25)], n),
+        "taster_id":  rng.choice([f"J{i:02d}" for i in range(1, 13)], n),
+        "flight":     rng.choice(["Flight A", "Flight B", "Flight C"], n),
+        "aroma_intensity": rng.normal(6.1, 1.7, n).round(1).clip(1, 10),
+        "fruit_score": fruit,
+        "tannin_score": structure,
+        "acidity_score": rng.normal(6.2, 1.4, n).round(1).clip(1, 10),
+        "finish_seconds": rng.gamma(4, 3.2, n).round(0).clip(2, 60),
+        # overall is mostly a blend of fruit and structure, plus taster noise
+        "overall_rating": (fruit * 0.5 + structure * 0.4 + rng.normal(0, 0.6, n)).round(1).clip(1, 10),
+        "would_purchase": rng.random(n) < 0.45,
+    })
+
+
+def harvest_logistics_df(n=240, seed=0):
+    """Pick-day operations: crews, bins, transport to the crush pad."""
+    rng = np.random.default_rng(seed)
+    crew = rng.integers(6, 25, n)
+    return pd.DataFrame({
+        "pick_date":   np.tile(pd.date_range("2024-08-20", periods=n // 6 + 1, freq="D"), 6)[:n],
+        "block":       rng.choice(BLOCKS, n),
+        "crew_id":     rng.choice(["Crew Alpha", "Crew Bravo", "Crew Charlie", "Crew Delta"], n),
+        "crew_size":   crew,
+        "pick_method": rng.choice(["Hand", "Machine"], n, p=[0.72, 0.28]),
+        # more pickers -> more bins, with diminishing returns and day-to-day noise
+        "bins_filled": (crew * 1.9 + rng.normal(0, 4, n)).round(0).clip(2, 70),
+        "kg_per_hour": rng.normal(410, 120, n).round(0).clip(80, 900),
+        "transport_km": rng.normal(14, 7, n).round(1).clip(0.5, 45),
+        "fruit_temp_c": rng.normal(17, 5, n).round(1).clip(4, 34),
+        "wait_time_min": rng.gamma(2.5, 14, n).round(0).clip(0, 180),
+        "mog_pct":     rng.normal(2.4, 1.3, n).round(2).clip(0, 12),   # material other than grapes
+    })
+
+
+def wine_sales_df(n=320, seed=0):
+    """Bottle sales by channel and region."""
+    rng = np.random.default_rng(seed)
+    price = rng.normal(38, 14, n).round(2).clip(9, 130)
+    return pd.DataFrame({
+        "order_date":  pd.date_range("2023-01-01", periods=n, freq="D"),
+        "sku":         rng.choice([f"SKU-{i:03d}" for i in range(1, 19)], n),
+        "region":      rng.choice(["Napa", "Sonoma", "Oregon", "Export EU", "Export Asia"], n),
+        "channel":     rng.choice(["Tasting Room", "Wine Club", "Distributor", "Online"], n),
+        "unit_price_usd": price,
+        # cheaper bottles move in larger volumes
+        "bottles_sold": (rng.gamma(3, 22, n) * (60 / price)).round(0).clip(1, 900),
+        "discount_pct": rng.choice([0, 5, 10, 15, 20, 25], n, p=[.4, .16, .16, .12, .1, .06]),
+        "shipping_cost_usd": rng.normal(22, 9, n).round(2).clip(0, 80),
+        "club_member":  rng.random(n) < 0.38,
+    })
+
+
+def canopy_pruning_df(n=200, seed=0):
+    """Dormant pruning and canopy architecture measurements per vine."""
+    rng = np.random.default_rng(seed)
+    shoots = rng.integers(12, 60, n)
+    return pd.DataFrame({
+        "vine_id":     np.arange(1000, 1000 + n),
+        "block":       rng.choice(BLOCKS, n),
+        "trellis_type": rng.choice(["VSP", "Lyre", "Head-trained", "Quadrilateral Cordon"], n),
+        "pruning_method": rng.choice(["Spur", "Cane", "Minimal"], n),
+        "shoot_count": shoots,
+        "bud_count":   (shoots * 1.4 + rng.normal(0, 3, n)).round(0).clip(8, 100),
+        # leaf area scales with how many shoots the vine carries
+        "leaf_area_m2": (shoots * 0.14 + rng.normal(0, 0.6, n)).round(2).clip(0.5, 12),
+        "cane_weight_kg": rng.normal(0.85, 0.3, n).round(3).clip(0.1, 2.5),
+        "internode_length_cm": rng.normal(7.5, 2.0, n).round(1).clip(2, 16),
+        "cluster_count": rng.integers(8, 55, n),
+    })
+
+
+def barrel_aging_df(n=220, seed=0):
+    """Barrel inventory and extraction chemistry during elevage."""
+    rng = np.random.default_rng(seed)
+    months = rng.integers(0, 25, n)
+    return pd.DataFrame({
+        "barrel_id":   rng.choice([f"B{i:04d}" for i in range(1, 121)], n),
+        "cooper":      rng.choice(["Taransaud", "Seguin Moreau", "Francois Freres",
+                                   "Nadalie", "World Cooperage"], n),
+        "oak_origin":  rng.choice(["French", "American", "Hungarian"], n),
+        "toast_level": rng.choice(["Light", "Medium", "Medium Plus", "Heavy"], n),
+        "months_in_barrel": months,
+        "barrel_age_fills": rng.integers(1, 6, n),
+        # oak compounds extract over time in barrel
+        "vanillin_ppb": (months * 21 + rng.normal(0, 45, n)).round(0).clip(0, 700),
+        "oak_lactone_ppb": (months * 14 + rng.normal(0, 38, n)).round(0).clip(0, 500),
+        "color_intensity_au": rng.normal(11.5, 3.0, n).round(2).clip(2, 22),
+        "topping_volume_l": rng.gamma(2, 0.9, n).round(2).clip(0, 9),
+    })
+
+
+GENERATORS = [
+    block_vintage_df,
+    phenology_df,
+    berry_chem_df,
+    cellar_ferment_df,
+    soil_survey_df,
+    pest_scouting_df,
+    irrigation_sensor_df,
+    sensory_panel_df,
+    harvest_logistics_df,
+    wine_sales_df,
+    canopy_pruning_df,
+    barrel_aging_df,
+]
+
+
+def df_preview(df, n=5):
+    """The EXACT schema string the model sees at train AND inference time.
+
+    Keep this the single source of truth -- any drift between train/infer
+    formatting pushes the model out of distribution.
+    """
+    dtypes = ", ".join(f"{c} ({df[c].dtype})" for c in df.columns)
+    return f"Columns and dtypes:\n  {dtypes}\nSample rows:\n{df.head(n).to_string(index=False)}"