freesolo-flash-dev 0.2.37__tar.gz → 0.2.39__tar.gz

{freesolo_flash_dev-0.2.37 → freesolo_flash_dev-0.2.39}/Dockerfile.worker

@@ -42,7 +42,7 @@ ENV TRITON_CACHE_DIR=/opt/flash/kernelcache/triton \
 RUN mkdir -p /opt/flash/kernelcache/triton /opt/flash/kernelcache/inductor \
     /opt/flash/kernelcache/flashinfer_cubin /opt/flash/kernelcache/flashinfer
 
-# build-essential for Triton/Inductor (Liger) + any source builds; git for pip VCS installs.
+# build-essential for Triton/Inductor/chalk + any source builds; git for pip VCS installs.
 RUN apt-get update && apt-get install -y --no-install-recommends build-essential git curl \
     && rm -rf /var/lib/apt/lists/*
 
@@ -58,7 +58,6 @@ RUN pip install --no-cache-dir \
     "huggingface_hub>=0.25" \
     "accelerate>=1.4" \
     "wandb>=0.17" \
-    "liger-kernel>=0.5" \
     "flash-linear-attention @ git+https://github.com/fla-org/flash-linear-attention.git@f0e213dbd8b5fb90c3c7eca869ac1706d5377139" \
     "tilelang==0.1.11" \
     "apache-tvm-ffi==0.1.11" \
@@ -148,7 +147,7 @@ RUN TORCH_CUDA_ARCH_LIST="8.0 8.6 8.9 9.0 10.0 12.0" CAUSAL_CONV1D_FORCE_BUILD=T
 # affect another tenant). The redirect can't be a static image ENV: the volume mounts at a fixed path
 # only at runtime and only when attached, so a baked ENV would break cache-less (no-volume) cold runs.
 #
-# Compiled-kernel cache: OPT-IN bake, JIT fallback. The fused Triton (Liger/fla/chalk),
+# Compiled-kernel cache: OPT-IN bake, JIT fallback. The fused Triton (fla/chalk),
 # TorchInductor, and Hopper tilelang kernels the trainer builds on first use are content-addressed
 # by GPU ARCH + toolchain version, so they can only be compiled on a real GPU of each catalog arch
 # (8.0/8.6/8.9/9.0/12.0) — which the CI image builder normally lacks (the FA2 *source* path above
@@ -187,7 +186,7 @@ RUN if [ "${BUILD_KERNEL_CACHE}" = "true" ] && [ -f /opt/flash/kernelcache/mega_
 # Sanity: the worker imports must succeed (catches a broken stack at build time, not run time).
 # Import EVERY package the worker runtime uses (derived from a full AST scan of the engine/envs/
 # bootstrap code + the WORKER_DEPS list above): the core stack, the optimizer/accelerator libs
-# (liger, flash-linear-attention=fla, flash_attn, bitsandbytes, triton), and the HF/env libs. A
+# (flash-linear-attention=fla, flash_attn, bitsandbytes, triton), and the HF/env libs. A
 # missing or ABI-broken package fails the build HERE instead of silently shipping (the FA wheel in
 # particular can install yet fail to import against this torch). cuDNN comes from the base image.
 # flash_attn is BEST-EFFORT (the install above tolerates a build failure -> SDPA fallback), so it
@@ -195,7 +194,7 @@ RUN if [ "${BUILD_KERNEL_CACHE}" = "true" ] && [ -f /opt/flash/kernelcache/mega_
 # could never be produced. The rest of the stack is mandatory.
 RUN python -c "import importlib.metadata as M; \
 import torch, transformers, trl, peft, vllm, datasets, huggingface_hub, accelerate, wandb, \
-liger_kernel, fla, bitsandbytes, hf_transfer, triton, freesolo, runpod; \
+fla, bitsandbytes, hf_transfer, triton, freesolo, runpod; \
 import importlib; \
 fa_ok = False; \
 exec('try:\n import flash_attn\n fa_ok = True\nexcept Exception:\n fa_ok = False'); \
@@ -207,7 +206,7 @@ cudnn = torch.backends.cudnn.version(); assert cudnn, 'cuDNN not compiled into t
 ver = lambda n: M.version(n); \
 print('worker stack OK | torch', torch.__version__, '| cudnn', cudnn, '| triton', triton.__version__, '| flash_attn', 'present' if fa_ok else 'ABSENT (SDPA fallback)', '| flash_attn_3', 'present (Hopper FA3)' if fa3_ok else 'ABSENT (SDPA on Hopper)', '| flashinfer', 'present (B200 MoE/attn)' if fi_ok else 'ABSENT (Triton fused-MoE fallback)'); \
 [print('  ', d, ver(d)) for d in ['transformers','trl','peft','vllm','flashinfer-python','datasets','huggingface-hub', \
-'accelerate','wandb','liger-kernel','flash-linear-attention','bitsandbytes', \
+'accelerate','wandb','flash-linear-attention','bitsandbytes', \
 'hf-transfer','freesolo','runpod']]"
 
 # RunPod Serverless worker entrypoint (Pattern D — Flash custom image). Generate /rp_handler.py

{freesolo_flash_dev-0.2.37 → freesolo_flash_dev-0.2.39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freesolo-flash-dev
-Version: 0.2.37
+Version: 0.2.39
 Summary: Flash — managed LoRA post-training (SFT/GRPO) for Freesolo environments, driven by the `flash` CLI
 Project-URL: Homepage, https://github.com/freesolo-co/flash
 Project-URL: Repository, https://github.com/freesolo-co/flash

{freesolo_flash_dev-0.2.37 → freesolo_flash_dev-0.2.39}/docker/Dockerfile.kernelcache

@@ -1,7 +1,7 @@
 # Thin per-arch kernel-cache layer.
 #
 # Bakes a warmup-produced mega-cache ON TOP of the EXACT base image the warmup ran inside, so the
-# cache's toolchain (torch/triton/fla/liger) is guaranteed to match the image it ships in. Rebuilding
+# cache's toolchain (torch/triton/fla/chalk) is guaranteed to match the image it ships in. Rebuilding
 # the full Dockerfile.worker from the checkout instead could drift from the published base and bake a
 # cache that silently won't load (cold-JIT fallback) -- this avoids that by construction.
 #

{freesolo_flash_dev-0.2.37 → freesolo_flash_dev-0.2.39}/docker/bake_kernel_cache.py

@@ -100,16 +100,16 @@ def main() -> int:
     entry_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "bake_pod_entry.py")
     allowed_cuda = [v.strip() for v in args.allowed_cuda.split(",") if v.strip()] or None
 
-    # the chalk install spec the production worker uses (so the bake warms chalk's kernels too);
-    # FLASH_CHALK_SPEC overrides, else the source-of-truth DEFAULT_CHALK_SPEC, else a safe literal.
+    # The chalk install spec the production worker uses, so the bake warms the same kernels. Keep the
+    # default import fail-loud: a stale hidden fallback would silently bake against the wrong chalk SHA.
     chalk_spec = os.environ.get("FLASH_CHALK_SPEC", "").strip()
     if not chalk_spec:
         try:
             from flash.providers.runpod.train.deps import DEFAULT_CHALK_SPEC
 
             chalk_spec = DEFAULT_CHALK_SPEC
-        except Exception:
-            chalk_spec = "freesolo-chalk>=0.1.0,<0.2.0"
+        except Exception as exc:
+            raise RuntimeError("could not import DEFAULT_CHALK_SPEC for kernel-cache bake") from exc
 
     _upload_flash_code(api, repo, token)
 

{freesolo_flash_dev-0.2.37 → freesolo_flash_dev-0.2.39}/docker/kernel_fingerprint.py

@@ -11,7 +11,7 @@ Two fingerprints, because "out of date" has two flavors with very different cost
   * fp_cache = hash of the inputs whose kernels live in the baked mega-cache
     (torch.compiler.save_cache_artifacts: Triton/Inductor/torch.compile). Changing one of these
     INVALIDATES the cache, so the per-arch image needs a real GPU re-warm. These are: the base
-    FROM image (torch+triton), the fla git pin, liger, tilelang, apache-tvm-ffi, the default chalk
+    FROM image (torch+triton), the fla git pin, tilelang, apache-tvm-ffi, the default chalk
     spec, and the warmup script itself (it decides which kernels get compiled).
 
   * fp_base = hash of everything else baked into :cu128 that is NOT in the cache (FA2/FA3 wheels,
@@ -27,7 +27,7 @@ time, which is why every parse below FAILS LOUD rather than hashing a None.
 Known limitations (deliberately scoped -- each only ever costs a recoverable cold-JIT, never
 correctness, and the alternatives over-fire the paid GPU bake):
   * fp_cache hashes the Dockerfile dep PINS, not pip-resolved versions. A cache-affecting range
-    (liger-kernel>=, the chalk spec) could resolve a newer build on a later worker-image rebuild with
+    (the chalk spec) could resolve a newer build on a later worker-image rebuild with
     no text change, leaving fp_cache unmoved. Pin those exactly for airtight coverage. (fp_base DOES
     hash the whole Dockerfile.worker, so arbitrary base edits -- apt/ENV/CMD/cache-dir -- still
     trigger a free re-layer; only a cache-affecting change that isn't a parsed pin slips through.)
@@ -43,6 +43,7 @@ stdlib only, no flash/torch import, so it runs under a bare python3 in CI (no uv
 from __future__ import annotations
 
 import argparse
+import ast
 import hashlib
 import json
 import re
@@ -56,7 +57,7 @@ LABEL_REVISION = "org.opencontainers.image.revision"
 
 # pip specs in Dockerfile.worker's main stack whose kernels land in the mega-cache. everything else
 # in that block is a base-layer dep (fp_base). fla is matched separately (it carries the git sha).
-_CACHE_PKGS = {"liger-kernel", "tilelang", "apache-tvm-ffi"}
+_CACHE_PKGS = {"tilelang", "apache-tvm-ffi"}
 
 
 def _search(pattern: str, text: str, what: str, *, flags: int = 0) -> str:
@@ -71,6 +72,44 @@ def _sha256_file(path: Path) -> str:
     return hashlib.sha256(path.read_bytes()).hexdigest()
 
 
+def _python_string_constant(text: str, name: str, what: str) -> str:
+    """Resolve a simple module-level string constant, including f-strings using prior constants."""
+    values: dict[str, str] = {}
+
+    def _eval(node: ast.AST) -> str | None:
+        if isinstance(node, ast.Constant) and isinstance(node.value, str):
+            return node.value
+        if isinstance(node, ast.JoinedStr):
+            parts: list[str] = []
+            for value in node.values:
+                if isinstance(value, ast.Constant) and isinstance(value.value, str):
+                    parts.append(value.value)
+                elif (
+                    isinstance(value, ast.FormattedValue)
+                    and isinstance(value.value, ast.Name)
+                    and value.value.id in values
+                ):
+                    parts.append(values[value.value.id])
+                else:
+                    return None
+            return "".join(parts)
+        return None
+
+    tree = ast.parse(text)
+    for node in tree.body:
+        if not isinstance(node, ast.Assign):
+            continue
+        value = _eval(node.value)
+        if value is None:
+            continue
+        for target in node.targets:
+            if isinstance(target, ast.Name):
+                values[target.id] = value
+    if name not in values:
+        raise ValueError(f"kernel_fingerprint: could not parse {what}")
+    return values[name]
+
+
 def _pip_stack_specs(dockerfile: str) -> list[str]:
     """The quoted specs from Dockerfile.worker's first `pip install` block (the pinned worker stack)."""
     specs: list[str] = []
@@ -104,13 +143,13 @@ def collect_inputs(
 
     Each value comes from where the IMAGE actually gets it:
       * pins / FROM / causal-conv1d from Dockerfile.worker (what the image is built from),
-      * default chalk spec textually from deps.py (what the bake warms),
+      * default chalk spec textually from _worker.py (what the bake warms),
       * FA2/FA3 from worker-image.yml's build-args (overridable via fa2_spec/fa3_spec for the
         resolved-build-arg case), and file hashes for the warmup/handler sources.
     base_inputs_partial does NOT yet include fp_cache; compute_fingerprints folds it in.
     """
     dockerfile = (root / "Dockerfile.worker").read_text()
-    deps = (root / "flash" / "providers" / "runpod" / "train" / "deps.py").read_text()
+    worker_pkg = (root / "flash" / "providers" / "_worker.py").read_text()
     worker_image_yml = (root / ".github" / "workflows" / "worker-image.yml").read_text()
 
     specs = _pip_stack_specs(dockerfile)
@@ -129,12 +168,13 @@ def collect_inputs(
         raise ValueError(
             "kernel_fingerprint: fla spec missing or not pinned to a 40-char commit sha"
         )
-    chalk = _search(r'DEFAULT_CHALK_SPEC\s*=\s*"([^"]+)"', deps, "deps.py DEFAULT_CHALK_SPEC")
+    chalk = _python_string_constant(
+        worker_pkg, "DEFAULT_CHALK_SPEC", "_worker.py DEFAULT_CHALK_SPEC"
+    )
 
     cache_inputs = {
         "from_image": from_image,
         "fla": fla,
-        "liger": _need("liger-kernel"),
         "tilelang": _need("tilelang"),
         "tvm_ffi": _need("apache-tvm-ffi"),
         "chalk": chalk,

{freesolo_flash_dev-0.2.37 → freesolo_flash_dev-0.2.39}/flash/catalog.py

@@ -115,9 +115,16 @@ class ModelInfo:
 
 DEFAULT_MODEL = "Qwen/Qwen3.5-4B"
 
+# The pre-quantized FP8 checkpoint each base model's serving engine LOADS (mirrors serving's
+# ``src.prequant_config``). Every dense model now serves a Freesolo-OWNED FP8_DYNAMIC checkpoint (no
+# community-repo dependence); the 35B VL MoE serves the OFFICIAL Qwen FP8 (it preserves the full
+# vision-language model). Informational for the catalog mirror — deploy gating reads only max_lora_rank.
 SERVING_FP8_MODEL_REPOS: dict[str, str] = {
-    "Qwen/Qwen3.5-4B": "lovedheart/Qwen3.5-4B-FP8",
-    "Qwen/Qwen3.5-9B": "lovedheart/Qwen3.5-9B-FP8",
+    "openbmb/MiniCPM5-1B": "Freesolo-Co/MiniCPM5-1B-FP8",
+    "Qwen/Qwen3.5-0.8B": "Freesolo-Co/Qwen3.5-0.8B-FP8",
+    "Qwen/Qwen3.5-2B": "Freesolo-Co/Qwen3.5-2B-FP8",
+    "Qwen/Qwen3.5-4B": "Freesolo-Co/Qwen3.5-4B-FP8",
+    "Qwen/Qwen3.5-9B": "Freesolo-Co/Qwen3.5-9B-FP8",
     "Qwen/Qwen3.6-35B-A3B": "Qwen/Qwen3.6-35B-A3B-FP8",
 }
 
@@ -133,9 +140,10 @@ MODELS: dict[str, ModelInfo] = {
         recommended_gpu="RTX 4090",
         serving=ServingCapacity(
             gpu="L4",
+            serve_model_id=SERVING_FP8_MODEL_REPOS["openbmb/MiniCPM5-1B"],
             max_loras=16,
-            max_lora_rank=64,
-            max_model_len=32768,
+            max_lora_rank=128,
+            max_model_len=8192,
         ),
         thinking="hybrid",
         notes="On-device class SLM (131k ctx); standard Llama architecture.",
@@ -151,9 +159,10 @@ MODELS: dict[str, ModelInfo] = {
         recommended_gpu="RTX 4090",
         serving=ServingCapacity(
             gpu="L4",
+            serve_model_id=SERVING_FP8_MODEL_REPOS["Qwen/Qwen3.5-0.8B"],
             max_loras=16,
-            max_lora_rank=64,
-            max_model_len=32768,
+            max_lora_rank=128,
+            max_model_len=8192,
         ),
         thinking="hybrid",
         notes="Smallest Qwen3.5; cheap smoke/dev runs with the modern arch.",
@@ -169,9 +178,10 @@ MODELS: dict[str, ModelInfo] = {
         recommended_gpu="RTX 4090",
         serving=ServingCapacity(
             gpu="L4",
+            serve_model_id=SERVING_FP8_MODEL_REPOS["Qwen/Qwen3.5-2B"],
             max_loras=16,
-            max_lora_rank=64,
-            max_model_len=32768,
+            max_lora_rank=128,
+            max_model_len=8192,
         ),
         thinking="hybrid",
     ),
@@ -187,8 +197,8 @@ MODELS: dict[str, ModelInfo] = {
         serving=ServingCapacity(
             gpu="L4",
             serve_model_id=SERVING_FP8_MODEL_REPOS["Qwen/Qwen3.5-4B"],
-            max_loras=64,
-            max_lora_rank=32,
+            max_loras=16,
+            max_lora_rank=64,
             max_model_len=8192,
             max_num_seqs=8,
             gpu_memory_utilization=0.98,
@@ -212,8 +222,8 @@ MODELS: dict[str, ModelInfo] = {
         serving=ServingCapacity(
             gpu="L4",
             serve_model_id=SERVING_FP8_MODEL_REPOS["Qwen/Qwen3.5-9B"],
-            max_loras=44,
-            max_lora_rank=32,
+            max_loras=16,
+            max_lora_rank=64,
             max_model_len=8192,
             max_num_seqs=8,
             gpu_memory_utilization=0.98,
@@ -250,8 +260,11 @@ MODELS: dict[str, ModelInfo] = {
         serving=ServingCapacity(
             gpu="A100-80GB",
             serve_model_id=SERVING_FP8_MODEL_REPOS["Qwen/Qwen3.6-35B-A3B"],
-            max_loras=12,
-            max_lora_rank=32,
+            # rank-64 at only 6 hot slots: the fused-MoE LoRA buffer scales with
+            # max_loras x rank x num_experts, so the A100-80GB ceiling is ~max_loras x rank = 384
+            # (6 x 64 fits at 99.3% util; 16 x 64 OOMs on every single/multi GPU). Serving-validated.
+            max_loras=6,
+            max_lora_rank=64,
             max_model_len=8192,
             max_num_seqs=8,
             max_num_batched_tokens=4096,

{freesolo_flash_dev-0.2.37 → freesolo_flash_dev-0.2.39}/flash/cli/__init__.py

@@ -253,8 +253,7 @@ def _build_parser() -> argparse.ArgumentParser:
     )
     env_pull.add_argument(
         "env_id",
-        help='the Freesolo environment id: a managed slug "your-name/your-env", a '
-        '"github:owner/repo@ref:path" ref, or a github.com URL',
+        help='the managed Freesolo environment slug "your-name/your-env"',
     )
     env_pull.add_argument(
         "path",

{freesolo_flash_dev-0.2.37 → freesolo_flash_dev-0.2.39}/flash/cli/envpush.py

@@ -65,38 +65,32 @@ def _normalize_managed_hub_id(raw: object) -> tuple[str | None, _ManagedHubIdErr
 def cmd_env_pull(args) -> int:
     """Download a published Freesolo environment (or a single file from it) to local disk.
 
-    Managed hub slugs pull package tarballs through the authenticated Flash control plane. Explicit
-    GitHub refs still pull via GitHub's tarball / raw media type, so files larger than 1 MB
-    (e.g. ``datasets/train.jsonl``) come back intact instead of empty.
+    Environments are addressed by their managed hub slug ``namespace/name`` and pulled as package
+    tarballs through the authenticated Flash control plane.
     """
     from flash.client import ClientError, client_from_config
-    from flash.envs.adapter import is_freesolo_environment_id
     from flash.envs.pull import (
-        download_environment_file,
         download_environment_file_from_archive,
         ensure_environment_pull_destination_available,
         environment_local_dirname,
-        pull_environment_package,
         pull_environment_package_from_archive,
     )
 
     env_id = str(args.env_id or "").strip()
-    if not is_freesolo_environment_id(env_id):
+    managed_env_id, managed_error = _normalize_managed_hub_id(env_id)
+    if managed_error == "not-canonical":
+        return _err(
+            f'env id must be lowercase "namespace/name" with no spaces (got {args.env_id!r})'
+        )
+    if managed_env_id is None:
         print(
-            'env id must be a Freesolo environment id — a managed slug "your-name/your-env", '
-            f'a "github:owner/repo@ref:path" ref, or a github.com URL (got {args.env_id!r})',
+            'env id must be a managed Freesolo hub slug "your-name/your-env" '
+            f"(got {args.env_id!r})",
             file=sys.stderr,
         )
         return 1
+    env_id = managed_env_id
     try:
-        managed_env_id, managed_error = _normalize_managed_hub_id(env_id)
-        if managed_error == "not-canonical":
-            return _err(
-                f'env id must be lowercase "namespace/name" with no spaces (got {args.env_id!r})'
-            )
-        managed = managed_env_id is not None
-        if managed:
-            env_id = managed_env_id
         if args.path:
             default_name = Path(args.path.replace("\\", "/")).name
             out = Path(args.output) if args.output else Path(default_name)
@@ -110,11 +104,8 @@ def cmd_env_pull(args) -> int:
             if (out.exists() or out.is_symlink()) and not args.force:
                 print(f"refusing to overwrite {out} (pass --force)", file=sys.stderr)
                 return 1
-            if managed:
-                package = client_from_config().download_env_package(env_id)
-                data = download_environment_file_from_archive(package, args.path)
-            else:
-                data = download_environment_file(env_id, args.path)
+            package = client_from_config().download_env_package(env_id)
+            data = download_environment_file_from_archive(package, args.path)
             out.parent.mkdir(parents=True, exist_ok=True)
             _atomic_write_bytes(out, data)
             if render.styled():
@@ -123,12 +114,9 @@ def cmd_env_pull(args) -> int:
                 print(f"pulled {args.path} from {env_id} -> {out} ({len(data):,} bytes)")
         else:
             out = Path(args.output) if args.output else Path(environment_local_dirname(env_id))
-            if managed:
-                ensure_environment_pull_destination_available(out, overwrite=args.force)
-                package = client_from_config().download_env_package(env_id)
-                pull_environment_package_from_archive(package, out, overwrite=args.force)
-            else:
-                pull_environment_package(env_id, out, overwrite=args.force)
+            ensure_environment_pull_destination_available(out, overwrite=args.force)
+            package = client_from_config().download_env_package(env_id)
+            pull_environment_package_from_archive(package, out, overwrite=args.force)
             if render.styled():
                 print(render.env_pulled(f"{out}/", env_id))
             else:
@@ -146,12 +134,6 @@ def cmd_env_pull(args) -> int:
         return 1
     except (ValueError, FileNotFoundError, RuntimeError, OSError) as exc:
         print(f"env pull failed: {exc}", file=sys.stderr)
-        if "GitHub environment request failed" in str(exc) and not os.environ.get("GITHUB_TOKEN"):
-            print(
-                "hint: private/internal environments need a GitHub token; set GITHUB_TOKEN "
-                "(e.g. `export GITHUB_TOKEN=$(gh auth token)`).",
-                file=sys.stderr,
-            )
         return 1
 
 

{freesolo_flash_dev-0.2.37 → freesolo_flash_dev-0.2.39}/flash/cli/render.py

@@ -359,6 +359,8 @@ def _color_json(obj, depth: int) -> str:
 
 def _hide_provider_metadata(obj):
     """Styled CLI details are for humans; keep backend provider names out of that view."""
+    from flash.providers import PROVIDER_NAMES
+
     if isinstance(obj, dict):
         return {
             k: _hide_provider_metadata(v)
@@ -367,7 +369,7 @@ def _hide_provider_metadata(obj):
         }
     if isinstance(obj, list):
         return [_hide_provider_metadata(v) for v in obj]
-    if isinstance(obj, str) and obj.lower() in {"runpod", "lambda"}:
+    if isinstance(obj, str) and obj.lower() in PROVIDER_NAMES:
         return "managed"
     return obj
 

{freesolo_flash_dev-0.2.37 → freesolo_flash_dev-0.2.39}/flash/cost/analytical.py

@@ -98,7 +98,6 @@ def seconds_per_step(config: RunConfig, gpu: str) -> float:
     reward_s = math.ceil(completions / REWARD_CONCURRENCY) * latency  # ceil: a partial wave still costs one latency
     return gen_s + reward_s + update_s
 
-
 def sft_seconds_for_tokens(config: RunConfig, gpu: str, train_tokens: float) -> float:
     """SFT steady-state wall time for an actual token count on ``gpu``."""
     n = config.normalized()
@@ -108,7 +107,7 @@ def sft_seconds_for_tokens(config: RunConfig, gpu: str, train_tokens: float) ->
     return flops / (peak * MFU_SFT_TRAIN)
 
 
-def select_gpu(config: RunConfig) -> tuple[str, int]:
+def select_gpu(config: RunConfig, *, max_wall_seconds: float = 0.0) -> tuple[str, int]:
     """(chosen GPU class, required VRAM GB): the cheapest fitting class for the cost.
 
     Uses ``pick_gpu``, which (unlike the submit-time allocator) intentionally stays gate-free —
@@ -122,7 +121,7 @@ def select_gpu(config: RunConfig) -> tuple[str, int]:
         train=config.train_knobs(),
         thinking=config.thinking,
     )
-    gpu = pick_gpu(need, provider=config.provider)
+    gpu = pick_gpu(need, provider=config.provider, max_wall_seconds=max_wall_seconds)
     return gpu, need
 
 
@@ -153,10 +152,26 @@ def _notes(config: RunConfig, raw_train_s: float, wall_capped: bool, cap_s: floa
 
 def estimate_cost(config: RunConfig, *, wall_cap_s: float = DEFAULT_WALL_CAP_S) -> CostEstimate:
     """Deterministic pre-flight cost calculation."""
-    gpu, need = select_gpu(config)
-    hourly = gpu_hourly_usd(gpu, provider=config.provider)
-    # Mirror the runner's max(60, max_wall_seconds) floor so elapsed wall time is not undercounted.
+    # Billing cap: mirror the runner's max(60, max_wall_seconds) floor so a sub-60s cap isn't underpriced.
     cap_s = max(60.0, float(config.max_wall_seconds)) if config.max_wall_seconds is not None else wall_cap_s
+    # Vast market duration filter: price against offers that outlast the run, using the SAME semantics
+    # ``usable_offers`` applies at LAUNCH (not the 60s-floored billing cap_s) — a non-positive wall means
+    # NO filter, a positive one is floored at 60s by usable_offers itself:
+    #   None -> the 24h spec default the run runs under (== DEFAULT_WALL_CAP_S);
+    #   > 0  -> that wall;   <= 0 -> 0.0 (no filter, exactly like launch).
+    if config.max_wall_seconds is None:
+        market_wall_s = wall_cap_s
+    elif config.max_wall_seconds > 0:
+        market_wall_s = float(config.max_wall_seconds)
+    else:
+        market_wall_s = 0.0
+    gpu, need = select_gpu(config, max_wall_seconds=market_wall_s)
+    # Quote the SAME VRAM-floored Vast market pick_gpu selected under (min_vram_gb=need): without the
+    # floor the rate lookup searches from the smallest managed class, letting cheap small-card offers
+    # crowd a high-VRAM selection off the limited page -> it silently falls back to the static rate.
+    hourly = gpu_hourly_usd(
+        gpu, provider=config.provider, max_wall_seconds=market_wall_s, min_vram_gb=need
+    )
 
     setup = setup_seconds(config)
     sps = seconds_per_step(config, gpu)

freesolo_flash_dev-0.2.39/flash/cost/facts.py

@@ -0,0 +1,161 @@
+"""Static lookup facts for the cost model: GPU price/VRAM/compute + cheapest-fit
+selection, model size/quant, and reward-grader latency. Pure tables + accessors."""
+
+from __future__ import annotations
+
+from flash.catalog import MODELS
+from flash.providers.base import GPU_INFO, GpuClass, providers_for
+
+GPU_COMPUTE_TFLOPS: dict[str, float] = {
+    # A10: 125 TFLOPS dense bf16 tensor (NVIDIA spec); Lambda-only 24 GB class, else defaults to 100.
+    "A10": 125.0,
+    "RTX 4090": 165.0,
+    "RTX 5090": 210.0,
+    "A100 PCIe": 312.0,
+    "A100 SXM": 312.0,
+    # A100 SXM 40GB: same SMs/tensor cores as the 80GB A100 SXM, less HBM only.
+    # Without this, 33-40 GB Lambda/Vast quotes fall back to _DEFAULT_TFLOPS.
+    "A100 SXM 40GB": 312.0,
+    "H100": 990.0,
+    # H200: same SMs/tensor cores as H100, more HBM only.
+    "H200": 990.0,
+    "RTX Pro 6000": 250.0,
+    # B200: 2.25 PFLOPS bf16 dense (NVIDIA spec); prevents ~10x cost over-estimate vs _DEFAULT_TFLOPS.
+    "B200": 2250.0,
+}
+_DEFAULT_TFLOPS = 100.0
+
+
+def gpu_tflops(name: str) -> float:
+    """Peak bf16 tensor TFLOPS for a managed GPU class."""
+    return GPU_COMPUTE_TFLOPS.get(name, _DEFAULT_TFLOPS)
+
+
+def gpu_hourly_usd(
+    name: str, provider: str | None = None, max_wall_seconds: float = 0.0, min_vram_gb: int = 0
+) -> float:
+    """Representative $/hr for a class, on ``provider`` when given.
+
+    When ``provider`` is ``lambda`` or ``vast`` and the class is offered there, price it through that
+    provider's pricing module (live with a static fallback); otherwise use the RunPod static rate.
+
+    ``max_wall_seconds`` (>0) is threaded into the Vast live market so a duration-bound quote prices
+    against offers that outlast the run, not a short-lived one filtered out at launch.
+
+    ``min_vram_gb`` (>0) floors the Vast market search at the job's required VRAM — the SAME floor
+    ``pick_gpu`` selected under — so a high-VRAM class isn't crowded off the price-sorted page and
+    misquoted on the static fallback (selection/quote parity).
+    """
+    info = GPU_INFO.get(name)
+    if info is None:
+        raise KeyError(f"unknown GPU class {name!r}")
+    p = (provider or "").strip().lower()
+    if p == "lambda" and info.lambda_name:
+        from flash.providers import get_provider
+
+        return get_provider("lambda").hourly_rate(name)
+    if p == "vast" and info.vast_name:
+        # Vast is a live market whose rates differ materially from RunPod's static ones, so price a
+        # provider="vast" quote through the Vast pricing module (live + static fallback).
+        from flash.providers.vast.pricing import hourly_rate
+
+        return hourly_rate(name, max_wall_seconds=max_wall_seconds, min_vram_gb=min_vram_gb)
+    return info.hourly_usd
+
+
+def gpu_vram_gb(name: str) -> int:
+    info = GPU_INFO.get(name)
+    if info is None:
+        raise KeyError(f"unknown GPU class {name!r}")
+    return info.vram_gb
+
+
+def pick_gpu(
+    required_vram_gb: int, *, provider: str | None = None, max_wall_seconds: float = 0.0
+) -> str:
+    """Cheapest GPU class that fits ``required_vram_gb``, ranked by static $/hr.
+
+    No pin; every fitting class is eligible, validated or not. NOTE this is intentionally
+    gate-free: the submit-time allocator restricts to the validated pool, so the
+    actually-provisioned class can be pricier than the one priced here. ``provider`` restricts
+    candidates to what it can provision. ``max_wall_seconds`` (>0) prices the Vast market against
+    offers that outlast the run, so a long-run quote doesn't SELECT a class on the strength of a
+    short-lived offer that won't survive to launch.
+    """
+
+    def _selectable(g: GpuClass) -> bool:
+        return provider in (None, "auto") or provider in providers_for(g.name)
+
+    candidates = [g for g in GPU_INFO.values() if g.vram_gb >= required_vram_gb and _selectable(g)]
+    if not candidates:
+        raise ValueError(f"no GPU class fits >= {required_vram_gb} GB")
+    # Rank by the rate on the REQUESTED provider, not the RunPod nominal. For Vast, fetch the live offer
+    # map ONCE (a duration-bound query bypasses the per-call cache, so pricing per candidate would fire N
+    # identical market fetches) and, when reachable, restrict to classes that actually have a rentable
+    # offer under the wall cap and rank by LIVE price — else a cheaper class with no surviving offer gets
+    # selected/quoted on a static rate the launch path would never rent. Static fallback when offline.
+    if (provider or "").strip().lower() == "vast":
+        from flash.providers.vast.pricing import live_offer_rates
+
+        live = live_offer_rates(max_wall_seconds=max_wall_seconds, min_vram_gb=required_vram_gb)
+        rentable = [g for g in candidates if g.name in live] if live else []
+        if rentable:
+            candidates = rentable
+
+            def _rate(g: GpuClass) -> float:
+                return live[g.name]
+        else:
+
+            def _rate(g: GpuClass) -> float:
+                return g.hourly_usd
+    else:
+
+        def _rate(g: GpuClass) -> float:
+            return gpu_hourly_usd(g.name, provider=provider, max_wall_seconds=max_wall_seconds)
+
+    best = min(candidates, key=lambda g: (_rate(g), g.vram_gb, g.name))
+    return best.name
+
+
+def total_params_b(model_id: str) -> float:
+    """Total parameter count (billions) for a catalog model."""
+    info = MODELS.get(model_id)
+    if info is None:
+        raise ValueError(
+            f"unknown model {model_id!r}; cost estimation supports catalog models only "
+            f"({', '.join(MODELS)})"
+        )
+    return info.params_b
+
+
+def active_params_b(model_id: str) -> float:
+    """Active params per token (billions); falls back to total for dense models. Use for FLOPs, not VRAM."""
+    info = MODELS.get(model_id)
+    if info is None:
+        raise ValueError(
+            f"unknown model {model_id!r}; cost estimation supports catalog models only "
+            f"({', '.join(MODELS)})"
+        )
+    return info.active_params_b or info.params_b
+
+
+def model_quant(model_id: str) -> str:
+    """Quantization of the catalog entry; defaults to 'bf16'."""
+    info = MODELS.get(model_id)
+    return (info.quant or "bf16") if info is not None else "bf16"
+
+
+def download_weight_gb(model_id: str) -> float:
+    """Full bf16 checkpoint size in GB (2 bytes/param)."""
+    return total_params_b(model_id) * 2.0
+
+
+# ~1s mid-range default across grader types (regex ~0.01s to LLM judge ~3s).
+AVG_REWARD_SECONDS_PER_COMPLETION = 1.0
+
+
+def reward_seconds_per_completion(override: float | None = None) -> float:
+    """Per-completion reward latency (s): the explicit override, else the single average."""
+    if override is not None:
+        return max(0.0, override)
+    return AVG_REWARD_SECONDS_PER_COMPLETION